git.opendaylight Code Review - netvirt.git/blob

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