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 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
  48     public AbstractIpLearnNotificationHandler(DataBroker dataBroker, IdManagerService idManager,
  49             IInterfaceManager interfaceManager, VpnConfig vpnConfig) {
  50         this.dataBroker = dataBroker;
  51         this.idManager = idManager;
  52         this.interfaceManager = interfaceManager;
  53         this.config = vpnConfig;
  54
  55         long duration = config.getArpLearnTimeout() * 10;
  56         long cacheSize = config.getArpCacheSize().longValue();
  57         migrateIpCache =
  58                 CacheBuilder.newBuilder().maximumSize(cacheSize).expireAfterWrite(duration,
  59                         TimeUnit.MILLISECONDS).build();
  60     }
  61
  62     protected void validateAndProcessIpLearning(String srcInterface, IpAddress srcIP, MacAddress srcMac,
  63             IpAddress targetIP, BigInteger metadata) {
  64         List<Adjacency> adjacencies = VpnUtil.getAdjacenciesForVpnInterfaceFromConfig(dataBroker, srcInterface);
  65         if (adjacencies != null) {
  66             for (Adjacency adj : adjacencies) {
  67                 IpPrefix ipPrefix = new IpPrefix(adj.getIpAddress().toCharArray());
  68                 if (NWUtil.isIpAddressInRange(srcIP, ipPrefix)) {
  69                     return;
  70                 }
  71             }
  72         }
  73
  74         LOG.trace("ARP/NA Notification Response Received from interface {} and IP {} having MAC {}, learning MAC",
  75                 srcInterface, String.valueOf(srcIP.getValue()), srcMac.getValue());
  76         processIpLearning(srcInterface, srcIP, srcMac, metadata, targetIP);
  77     }
  78
  79     protected void processIpLearning(String srcInterface, IpAddress srcIP, MacAddress srcMac, BigInteger metadata,
  80             IpAddress dstIP) {
  81         if (metadata != null && !Objects.equals(metadata, BigInteger.ZERO)) {
  82             Optional<List<String>> vpnList = VpnUtil.getVpnHandlingAssociatedWithInterface(dataBroker, srcInterface);
  83             if (vpnList.isPresent()) {
  84                 String srcIpToQuery = String.valueOf(srcIP.getValue());
  85                 String destIpToQuery = String.valueOf(dstIP.getValue());
  86                 for (String vpnName : vpnList.get()) {
  87                     LOG.info("Received ARP/NA for sender MAC {} and sender IP {} via interface {}",
  88                               srcMac.getValue(), srcIpToQuery, srcInterface);
  89                     VpnPortipToPort vpnPortipToPort =
  90                             VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker, vpnName, srcIpToQuery);
  91                     if (vpnPortipToPort != null) {
  92                         /* This is a well known neutron port and so should be ignored
  93                          * from being discovered
  94                          */
  95                         continue;
  96                     }
  97                     LearntVpnVipToPort learntVpnVipToPort = VpnUtil.getLearntVpnVipToPort(dataBroker,
  98                               vpnName, srcIpToQuery);
  99                     if (learntVpnVipToPort != null) {
 100                         String oldPortName = learntVpnVipToPort.getPortName();
 101                         String oldMac = learntVpnVipToPort.getMacAddress();
 102                         if (!oldMac.equalsIgnoreCase(srcMac.getValue())) {
 103                             //MAC has changed for requested IP
 104                             LOG.info("ARP/NA Source IP/MAC data modified for IP {} with MAC {} and Port {}",
 105                                     srcIpToQuery, srcMac, srcInterface);
 106                             synchronized ((vpnName + srcIpToQuery).intern()) {
 107                                 VpnUtil.createLearntVpnVipToPortEvent(dataBroker, vpnName, srcIpToQuery, destIpToQuery,
 108                                         oldPortName, oldMac, LearntVpnVipToPortEventAction.Delete, null);
 109                                 putVpnIpToMigrateIpCache(vpnName, srcIpToQuery, srcMac);
 110                             }
 111                         }
 112                     } else if (!isIpInMigrateCache(vpnName, srcIpToQuery)) {
 113                         learnMacFromIncomingPacket(vpnName, srcInterface, srcIP, srcMac, dstIP);
 114                     }
 115                 }
 116             } else {
 117                 LOG.info("IP LEARN NO_RESOLVE: VPN  not configured. Ignoring responding to ARP/NA requests from this"
 118                         + " Interface {}.", srcInterface);
 119                 return;
 120
 121             }
 122         }
 123     }
 124
 125     private void learnMacFromIncomingPacket(String vpnName, String srcInterface, IpAddress srcIP, MacAddress srcMac,
 126             IpAddress dstIP) {
 127         String srcIpToQuery = String.valueOf(srcIP.getValue());
 128         String destIpToQuery = String.valueOf(dstIP.getValue());
 129         synchronized ((vpnName + srcIpToQuery).intern()) {
 130             VpnUtil.createLearntVpnVipToPortEvent(dataBroker, vpnName, srcIpToQuery, destIpToQuery, srcInterface,
 131                     srcMac.getValue(), LearntVpnVipToPortEventAction.Add, null);
 132         }
 133     }
 134
 135     private void putVpnIpToMigrateIpCache(String vpnName, String ipToQuery, MacAddress srcMac) {
 136         long cacheSize = config.getArpCacheSize().longValue();
 137         if (migrateIpCache.size() >= cacheSize) {
 138             LOG.debug("IP_MIGRATE_CACHE: max size {} reached, assuming cache eviction we still put IP {}"
 139                     + " vpnName {} with MAC {}", cacheSize, ipToQuery, vpnName, srcMac);
 140         }
 141         LOG.debug("IP_MIGRATE_CACHE: add to dirty cache IP {} vpnName {} with MAC {}", ipToQuery, vpnName, srcMac);
 142         migrateIpCache.put(new ImmutablePair<>(vpnName, ipToQuery),
 143                 new BigInteger(String.valueOf(System.currentTimeMillis())));
 144     }
 145
 146     private boolean isIpInMigrateCache(String vpnName, String ipToQuery) {
 147         if (migrateIpCache == null || migrateIpCache.size() == 0) {
 148             return false;
 149         }
 150         Pair<String, String> keyPair = new ImmutablePair<>(vpnName, ipToQuery);
 151         BigInteger prevTimeStampCached = migrateIpCache.getIfPresent(keyPair);
 152         if (prevTimeStampCached == null) {
 153             LOG.debug("IP_MIGRATE_CACHE: there is no IP {} vpnName {} in dirty cache, so learn it",
 154                     ipToQuery, vpnName);
 155             return false;
 156         }
 157         if (System.currentTimeMillis() > prevTimeStampCached.longValue() + config.getArpLearnTimeout()) {
 158             LOG.debug("IP_MIGRATE_CACHE: older than timeout value - remove from dirty cache IP {} vpnName {}",
 159                     ipToQuery, vpnName);
 160             migrateIpCache.invalidate(keyPair);
 161             return false;
 162         }
 163         LOG.debug("IP_MIGRATE_CACHE: younger than timeout value - ignore learning IP {} vpnName {}",
 164                 ipToQuery, vpnName);
 165         return true;
 166     }
 167 }