vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/iplearn/AbstractIpLearnNotificationHandler.java

   1 /*
   2  * Copyright (c) 2018 Alten Calsoft Labs India Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.netvirt.vpnmanager.iplearn;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.cache.Cache;
  13 import com.google.common.cache.CacheBuilder;
  14 import java.math.BigInteger;
  15 import java.util.List;
  16 import java.util.Objects;
  17 import java.util.concurrent.TimeUnit;
  18 import org.apache.commons.lang3.tuple.ImmutablePair;
  19 import org.apache.commons.lang3.tuple.Pair;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  22 import org.opendaylight.genius.mdsalutil.NWUtil;
  23 import org.opendaylight.netvirt.vpnmanager.VpnUtil;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventAction;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.vpn.config.rev161130.VpnConfig;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 public abstract class AbstractIpLearnNotificationHandler {
  37
  38     private static final Logger LOG = LoggerFactory.getLogger(AbstractIpLearnNotificationHandler.class);
  39
  40     // temp where Key is VPNInstance+IP and value is timestamp
  41     private final Cache<Pair<String, String>, BigInteger> migrateIpCache;
  42
  43     protected final DataBroker dataBroker;
  44     protected final IdManagerService idManager;
  45     protected final IInterfaceManager interfaceManager;
  46     protected final VpnConfig config;
  47     protected final VpnUtil vpnUtil;
  48
  49     public AbstractIpLearnNotificationHandler(DataBroker dataBroker, IdManagerService idManager,
  50             IInterfaceManager interfaceManager, VpnConfig vpnConfig, VpnUtil vpnUtil) {
  51         this.dataBroker = dataBroker;
  52         this.idManager = idManager;
  53         this.interfaceManager = interfaceManager;
  54         this.config = vpnConfig;
  55         this.vpnUtil = vpnUtil;
  56
  57         long duration = config.getIpLearnTimeout() * 10;
  58         long cacheSize = config.getMigrateIpCacheSize().longValue();
  59         migrateIpCache =
  60                 CacheBuilder.newBuilder().maximumSize(cacheSize).expireAfterWrite(duration,
  61                         TimeUnit.MILLISECONDS).build();
  62     }
  63
  64     protected void validateAndProcessIpLearning(String srcInterface, IpAddress srcIP, MacAddress srcMac,
  65             IpAddress targetIP, BigInteger metadata) {
  66         List<Adjacency> adjacencies = vpnUtil.getAdjacenciesForVpnInterfaceFromConfig(srcInterface);
  67         if (adjacencies != null) {
  68             for (Adjacency adj : adjacencies) {
  69                 IpPrefix ipPrefix = new IpPrefix(adj.getIpAddress().toCharArray());
  70                 if (NWUtil.isIpAddressInRange(srcIP, ipPrefix)) {
  71                     return;
  72                 }
  73             }
  74         }
  75
  76         LOG.trace("ARP/NA Notification Response Received from interface {} and IP {} having MAC {}, learning MAC",
  77                 srcInterface, String.valueOf(srcIP.getValue()), srcMac.getValue());
  78         processIpLearning(srcInterface, srcIP, srcMac, metadata, targetIP);
  79     }
  80
  81     protected void processIpLearning(String srcInterface, IpAddress srcIP, MacAddress srcMac, BigInteger metadata,
  82             IpAddress dstIP) {
  83         if (metadata != null && !Objects.equals(metadata, BigInteger.ZERO)) {
  84             Optional<List<String>> vpnList = vpnUtil.getVpnHandlingIpv4AssociatedWithInterface(srcInterface);
  85             if (vpnList.isPresent()) {
  86                 String srcIpToQuery = String.valueOf(srcIP.getValue());
  87                 String destIpToQuery = String.valueOf(dstIP.getValue());
  88                 for (String vpnName : vpnList.get()) {
  89                     LOG.info("Received ARP/NA for sender MAC {} and sender IP {} via interface {}",
  90                               srcMac.getValue(), srcIpToQuery, srcInterface);
  91                     VpnPortipToPort vpnPortipToPort =
  92                             vpnUtil.getNeutronPortFromVpnPortFixedIp(vpnName, srcIpToQuery);
  93                     if (vpnPortipToPort != null) {
  94                         /* This is a well known neutron port and so should be ignored
  95                          * from being discovered
  96                          */
  97                         continue;
  98                     }
  99                     LearntVpnVipToPort learntVpnVipToPort = vpnUtil.getLearntVpnVipToPort(vpnName, srcIpToQuery);
 100                     if (learntVpnVipToPort != null) {
 101                         String oldPortName = learntVpnVipToPort.getPortName();
 102                         String oldMac = learntVpnVipToPort.getMacAddress();
 103                         if (!oldMac.equalsIgnoreCase(srcMac.getValue())) {
 104                             //MAC has changed for requested IP
 105                             LOG.info("ARP/NA Source IP/MAC data modified for IP {} with MAC {} and Port {}",
 106                                     srcIpToQuery, srcMac, srcInterface);
 107                             synchronized ((vpnName + srcIpToQuery).intern()) {
 108                                 vpnUtil.createLearntVpnVipToPortEvent(vpnName, srcIpToQuery, destIpToQuery,
 109                                         oldPortName, oldMac, LearntVpnVipToPortEventAction.Delete, null);
 110                                 putVpnIpToMigrateIpCache(vpnName, srcIpToQuery, srcMac);
 111                             }
 112                         }
 113                     } else if (!isIpInMigrateCache(vpnName, srcIpToQuery)) {
 114                         learnMacFromIncomingPacket(vpnName, srcInterface, srcIP, srcMac, dstIP);
 115                     }
 116                 }
 117             } else {
 118                 LOG.info("IP LEARN NO_RESOLVE: VPN  not configured. Ignoring responding to ARP/NA requests from this"
 119                         + " Interface {}.", srcInterface);
 120                 return;
 121
 122             }
 123         }
 124     }
 125
 126     private void learnMacFromIncomingPacket(String vpnName, String srcInterface, IpAddress srcIP, MacAddress srcMac,
 127             IpAddress dstIP) {
 128         String srcIpToQuery = String.valueOf(srcIP.getValue());
 129         String destIpToQuery = String.valueOf(dstIP.getValue());
 130         synchronized ((vpnName + srcIpToQuery).intern()) {
 131             vpnUtil.createLearntVpnVipToPortEvent(vpnName, srcIpToQuery, destIpToQuery, srcInterface,
 132                     srcMac.getValue(), LearntVpnVipToPortEventAction.Add, null);
 133         }
 134     }
 135
 136     private void putVpnIpToMigrateIpCache(String vpnName, String ipToQuery, MacAddress srcMac) {
 137         long cacheSize = config.getMigrateIpCacheSize().longValue();
 138         if (migrateIpCache.size() >= cacheSize) {
 139             LOG.debug("IP_MIGRATE_CACHE: max size {} reached, assuming cache eviction we still put IP {}"
 140                     + " vpnName {} with MAC {}", cacheSize, ipToQuery, vpnName, srcMac);
 141         }
 142         LOG.debug("IP_MIGRATE_CACHE: add to dirty cache IP {} vpnName {} with MAC {}", ipToQuery, vpnName, srcMac);
 143         migrateIpCache.put(new ImmutablePair<>(vpnName, ipToQuery),
 144                 new BigInteger(String.valueOf(System.currentTimeMillis())));
 145     }
 146
 147     private boolean isIpInMigrateCache(String vpnName, String ipToQuery) {
 148         if (migrateIpCache == null || migrateIpCache.size() == 0) {
 149             return false;
 150         }
 151         Pair<String, String> keyPair = new ImmutablePair<>(vpnName, ipToQuery);
 152         BigInteger prevTimeStampCached = migrateIpCache.getIfPresent(keyPair);
 153         if (prevTimeStampCached == null) {
 154             LOG.debug("IP_MIGRATE_CACHE: there is no IP {} vpnName {} in dirty cache, so learn it",
 155                     ipToQuery, vpnName);
 156             return false;
 157         }
 158         if (System.currentTimeMillis() > prevTimeStampCached.longValue() + config.getIpLearnTimeout()) {
 159             LOG.debug("IP_MIGRATE_CACHE: older than timeout value - remove from dirty cache IP {} vpnName {}",
 160                     ipToQuery, vpnName);
 161             migrateIpCache.invalidate(keyPair);
 162             return false;
 163         }
 164         LOG.debug("IP_MIGRATE_CACHE: younger than timeout value - ignore learning IP {} vpnName {}",
 165                 ipToQuery, vpnName);
 166         return true;
 167     }
 168 }