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