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             // Check if this IP belongs to  external network
 111             if (vpnPortipToPort == null) {
 112                 String extSubnetId = vpnUtil.getAssociatedExternalSubnet(srcIpToQuery);
 113                 if (extSubnetId != null) {
 114                     vpnPortipToPort =
 115                             vpnUtil.getNeutronPortFromVpnPortFixedIp(extSubnetId, srcIpToQuery);
 116                 }
 117             }
 118             if (vpnPortipToPort != null) {
 119                 /* This is a well known neutron port and so should be ignored
 120                  * from being discovered...unless it is an Octavia VIP
 121                  */
 122                 String portName = vpnPortipToPort.getPortName();
 123                 Port neutronPort = neutronVpnManager.getNeutronPort(portName);
 124
 125                 if (neutronPort == null) {
 126                     LOG.warn("{} should have been a neutron port but could not retrieve it. Aborting processing",
 127                              portName);
 128                     continue;
 129                 }
 130
 131                 if (!"Octavia".equals(neutronPort.getDeviceOwner())) {
 132                     LOG.debug("Neutron port {} is not an Octavia port, ignoring", portName);
 133                     continue;
 134                 }
 135             }
 136
 137             LearntVpnVipToPort learntVpnVipToPort = vpnUtil.getLearntVpnVipToPort(vpnName, srcIpToQuery);
 138             if (learntVpnVipToPort != null) {
 139                 String oldPortName = learntVpnVipToPort.getPortName();
 140                 String oldMac = learntVpnVipToPort.getMacAddress();
 141                 if (!oldMac.equalsIgnoreCase(srcMac.getValue())) {
 142                     //MAC has changed for requested IP
 143                     LOG.info("ARP/NA Source IP/MAC data modified for IP {} with MAC {} and Port {}",
 144                             srcIpToQuery, srcMac, srcInterface);
 145                     synchronized ((vpnName + srcIpToQuery).intern()) {
 146                         vpnUtil.createLearntVpnVipToPortEvent(vpnName, srcIpToQuery, destIpToQuery,
 147                                 oldPortName, oldMac, LearntVpnVipToPortEventAction.Delete, null);
 148                         putVpnIpToMigrateIpCache(vpnName, srcIpToQuery, srcMac);
 149                     }
 150                 }
 151             } else if (!isIpInMigrateCache(vpnName, srcIpToQuery)) {
 152                 learnMacFromIncomingPacket(vpnName, srcInterface, srcIP, srcMac, dstIP);
 153             }
 154         }
 155     }
 156
 157     private void learnMacFromIncomingPacket(String vpnName, String srcInterface, IpAddress srcIP, MacAddress srcMac,
 158             IpAddress dstIP) {
 159         String srcIpToQuery = srcIP.stringValue();
 160         String destIpToQuery = dstIP.stringValue();
 161         synchronized ((vpnName + srcIpToQuery).intern()) {
 162             vpnUtil.createLearntVpnVipToPortEvent(vpnName, srcIpToQuery, destIpToQuery, srcInterface,
 163                     srcMac.getValue(), LearntVpnVipToPortEventAction.Add, null);
 164         }
 165     }
 166
 167     private void putVpnIpToMigrateIpCache(String vpnName, String ipToQuery, MacAddress srcMac) {
 168         long cacheSize = config.getMigrateIpCacheSize().longValue();
 169         if (migrateIpCache.size() >= cacheSize) {
 170             LOG.debug("IP_MIGRATE_CACHE: max size {} reached, assuming cache eviction we still put IP {}"
 171                     + " vpnName {} with MAC {}", cacheSize, ipToQuery, vpnName, srcMac);
 172         }
 173         LOG.debug("IP_MIGRATE_CACHE: add to dirty cache IP {} vpnName {} with MAC {}", ipToQuery, vpnName, srcMac);
 174         migrateIpCache.put(new ImmutablePair<>(vpnName, ipToQuery),
 175                 new BigInteger(String.valueOf(System.currentTimeMillis())));
 176     }
 177
 178     private boolean isIpInMigrateCache(String vpnName, String ipToQuery) {
 179         if (migrateIpCache == null || migrateIpCache.size() == 0) {
 180             return false;
 181         }
 182         Pair<String, String> keyPair = new ImmutablePair<>(vpnName, ipToQuery);
 183         BigInteger prevTimeStampCached = migrateIpCache.getIfPresent(keyPair);
 184         if (prevTimeStampCached == null) {
 185             LOG.debug("IP_MIGRATE_CACHE: there is no IP {} vpnName {} in dirty cache, so learn it",
 186                     ipToQuery, vpnName);
 187             return false;
 188         }
 189         if (System.currentTimeMillis() > prevTimeStampCached.longValue() + config.getIpLearnTimeout()) {
 190             LOG.debug("IP_MIGRATE_CACHE: older than timeout value - remove from dirty cache IP {} vpnName {}",
 191                     ipToQuery, vpnName);
 192             migrateIpCache.invalidate(keyPair);
 193             return false;
 194         }
 195         LOG.debug("IP_MIGRATE_CACHE: younger than timeout value - ignore learning IP {} vpnName {}",
 196                 ipToQuery, vpnName);
 197         return true;
 198     }
 199 }