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