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