vpnmanager/impl/src/main/java/org/opendaylight/netvirt/vpnmanager/iplearn/LearntVpnVipToPortEventProcessor.java

   1 /*
   2  * Copyright (c) 2018 Ericsson India Global Services 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 package org.opendaylight.netvirt.vpnmanager.iplearn;
   9
  10 import com.google.common.util.concurrent.ListenableFuture;
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.List;
  14 import java.util.Optional;
  15 import java.util.concurrent.Callable;
  16 import java.util.concurrent.ExecutionException;
  17 import java.util.concurrent.locks.ReentrantLock;
  18 import javax.annotation.PreDestroy;
  19 import javax.inject.Inject;
  20 import javax.inject.Singleton;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  23 import org.opendaylight.genius.infra.Datastore;
  24 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
  25 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
  26 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  27 import org.opendaylight.genius.mdsalutil.NWUtil;
  28 import org.opendaylight.genius.utils.JvmGlobalLocks;
  29 import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
  30 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  31 import org.opendaylight.infrautils.utils.concurrent.Executors;
  32 import org.opendaylight.mdsal.binding.api.DataBroker;
  33 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  34 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
  35 import org.opendaylight.mdsal.eos.binding.api.Entity;
  36 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
  37 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
  38 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
  39 import org.opendaylight.netvirt.vpnmanager.VpnConstants;
  40 import org.opendaylight.netvirt.vpnmanager.VpnUtil;
  41 import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventAction;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventData;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.event.data.LearntVpnVipToPortEvent;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.Adjacencies;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency.AdjacencyType;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyKey;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterfaceBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
  54 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  55 import org.opendaylight.yangtools.yang.common.Uint32;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 @Singleton
  60 public class LearntVpnVipToPortEventProcessor
  61         extends AbstractClusteredAsyncDataTreeChangeListener<LearntVpnVipToPortEvent> {
  62     private static final Logger LOG = LoggerFactory.getLogger(LearntVpnVipToPortEventProcessor.class);
  63     private final DataBroker dataBroker;
  64     private final ManagedNewTransactionRunner txRunner;
  65     private final IInterfaceManager interfaceManager;
  66     public static final String MIP_PROCESSING_JOB  = "MIP-JOB";
  67     private final JobCoordinator jobCoordinator;
  68     private final EntityOwnershipUtils entityOwnershipUtils;
  69     private EntityOwnershipCandidateRegistration candidateRegistration;
  70     private final VpnUtil vpnUtil;
  71
  72     @Inject
  73     public LearntVpnVipToPortEventProcessor(final DataBroker dataBroker, IInterfaceManager interfaceManager,
  74             EntityOwnershipService entityOwnershipService, final JobCoordinator jobCoordinator, VpnUtil vpnUtil) {
  75         super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier
  76                 .create(LearntVpnVipToPortEventData.class).child(LearntVpnVipToPortEvent.class),
  77                 Executors.newListeningSingleThreadExecutor("LearntVpnVipToPortEventProcessor", LOG));
  78         this.dataBroker = dataBroker;
  79         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
  80         this.interfaceManager = interfaceManager;
  81         this.jobCoordinator = jobCoordinator;
  82         this.entityOwnershipUtils = new EntityOwnershipUtils(entityOwnershipService);
  83         this.vpnUtil = vpnUtil;
  84         start();
  85     }
  86
  87     public void start() {
  88         LOG.info("{} start", getClass().getSimpleName());
  89         try {
  90             candidateRegistration = entityOwnershipUtils.getEntityOwnershipService()
  91                     .registerCandidate(new Entity(VpnConstants.IP_MONITORING_ENTITY,
  92                             VpnConstants.IP_MONITORING_ENTITY));
  93         } catch (CandidateAlreadyRegisteredException e) {
  94             LOG.error("Failed to register the entity {}", VpnConstants.IP_MONITORING_ENTITY);
  95         }
  96     }
  97
  98     @PreDestroy
  99     @Override
 100     public void close() {
 101         super.close();
 102         if (candidateRegistration != null) {
 103             candidateRegistration.close();
 104         }
 105     }
 106
 107     @Override
 108     public void update(InstanceIdentifier<LearntVpnVipToPortEvent> id, LearntVpnVipToPortEvent value,
 109             LearntVpnVipToPortEvent dataObjectModificationAfter) {
 110         // Updates does not make sense on an event queue .
 111         // NOTE: DONOT ADD ANY CODE HERE AND MAKE A CIRCUS
 112     }
 113
 114     @Override
 115     public void add(InstanceIdentifier<LearntVpnVipToPortEvent> identifier, LearntVpnVipToPortEvent value) {
 116         // AFTER PROCESSING THE EVENT, REMOVE THE EVENT FROM THE QUEUE
 117         entityOwnershipUtils.runOnlyInOwnerNode(VpnConstants.IP_MONITORING_ENTITY, VpnConstants.IP_MONITORING_ENTITY,
 118             jobCoordinator, "LearntVpnVipToPortEvent-Handler", () -> {
 119                 try {
 120                     String vpnName = value.getVpnName();
 121                     String ipAddress = value.getSrcFixedip();
 122                     if (value.getEventAction() == LearntVpnVipToPortEventAction.Add) {
 123                         jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(ipAddress, vpnName),
 124                                 new AddMipAdjacencyWorker(value));
 125                     }
 126                     if (value.getEventAction() == LearntVpnVipToPortEventAction.Delete) {
 127                         jobCoordinator.enqueueJob(VpnUtil.buildIpMonitorJobKey(ipAddress, vpnName),
 128                                 new DeleteMipAdjacencyWorker(value));
 129                     }
 130                 } finally {
 131                     // remove the processed event
 132                     vpnUtil.removeLearntVpnVipToPortEvent(value.getLearntVpnVipEventId(), null);
 133                 }
 134             });
 135     }
 136
 137     @Override
 138     public void remove(InstanceIdentifier<LearntVpnVipToPortEvent> key, LearntVpnVipToPortEvent value) {
 139         // Removals are triggered by add handling.
 140         // NOTE: DONOT ADD ANY CODE HERE AND MAKE A CIRCUS
 141     }
 142
 143     private class AddMipAdjacencyWorker implements Callable<List<? extends ListenableFuture<?>>> {
 144         String vpnName;
 145         String interfaceName;
 146         String srcIpAddress;
 147         String destIpAddress;
 148         String macAddress;
 149
 150         AddMipAdjacencyWorker(LearntVpnVipToPortEvent event) {
 151             this.vpnName = event.getVpnName();
 152             this.interfaceName = event.getPortName();
 153             this.srcIpAddress = event.getSrcFixedip();
 154             this.destIpAddress = event.getDestFixedip();
 155             this.macAddress = event.getMacAddress();
 156         }
 157
 158         @Override
 159         public List<ListenableFuture<Void>> call() {
 160             return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
 161                                                                         Datastore.OPERATIONAL, operTx -> {
 162                     addMipAdjacency(vpnName, interfaceName, srcIpAddress, macAddress, destIpAddress);
 163                     vpnUtil.createVpnPortFixedIpToPort(vpnName, srcIpAddress,
 164                             interfaceName, Boolean.TRUE, macAddress, null);
 165                     vpnUtil.createLearntVpnVipToPort(vpnName, srcIpAddress, interfaceName, macAddress, operTx);
 166                 }));
 167         }
 168
 169         private void addMipAdjacency(String vpnInstName, String vpnInterface, String srcPrefix, String mipMacAddress,
 170                                      String dstPrefix) {
 171             LOG.trace("Adding {} adjacency to VPN Interface {} ", srcPrefix, vpnInterface);
 172             InstanceIdentifier<VpnInterface> vpnIfId = VpnUtil.getVpnInterfaceIdentifier(vpnInterface);
 173             // FIXME: separate out to somehow?
 174             final ReentrantLock lock = JvmGlobalLocks.getLockForString(vpnInterface);
 175             lock.lock();
 176             try {
 177                 Optional<VpnInterface> optVpnInterface = SingleTransactionDataBroker.syncReadOptional(dataBroker,
 178                     LogicalDatastoreType.CONFIGURATION, vpnIfId);
 179                 if (!optVpnInterface.isPresent()) {
 180                     LOG.error("Config VpnInterface not found for interface={}", interfaceName);
 181                     return;
 182                 }
 183                 Adjacencies configAdjacencies = optVpnInterface.get().augmentation(Adjacencies.class);
 184                 List<Adjacency> adjacencyList = configAdjacencies == null ? new ArrayList<>()
 185                         : new ArrayList<>(configAdjacencies.getAdjacency());
 186
 187                 String ip = VpnUtil.getIpPrefix(srcPrefix);
 188                 AdjacencyBuilder newAdjBuilder;
 189                 if (interfaceManager.isExternalInterface(vpnInterface)) {
 190                     String subnetId = getSubnetId(vpnInstName, dstPrefix);
 191                     if (subnetId == null) {
 192                         LOG.trace("Can't find corresponding subnet for src IP {}, src MAC {}, dst IP {},"
 193                                 + "  in VPN {}", srcPrefix, mipMacAddress, dstPrefix, vpnInstName);
 194                         return;
 195                     }
 196                     newAdjBuilder = new AdjacencyBuilder().setIpAddress(ip).withKey(new AdjacencyKey(ip))
 197                             .setAdjacencyType(AdjacencyType.PrimaryAdjacency).setMacAddress(mipMacAddress)
 198                             .setSubnetId(new Uuid(subnetId)).setPhysNetworkFunc(true);
 199                 } else {
 200                     String nextHopIp = null;
 201                     String nextHopMacAddress = null;
 202                     for (Adjacency adjacency : adjacencyList) {
 203                         if (adjacency.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
 204                             if (adjacency.getIpAddress().equals(ip)) {
 205                                 LOG.error("The MIP {} is already present as a primary adjacency for interface {}."
 206                                         + "Skipping adjacency addition.", ip, interfaceName);
 207                                 return;
 208                             } else if (NWUtil.getEtherTypeFromIpPrefix(ip) == NWUtil
 209                                     .getEtherTypeFromIpPrefix(adjacency.getIpAddress())) {
 210                                 nextHopIp = adjacency.getIpAddress().split("/")[0];
 211                                 nextHopMacAddress = adjacency.getMacAddress();
 212                                 break;
 213                             }
 214                         }
 215                     }
 216                     if (nextHopIp == null) {
 217                         LOG.error("Next Hop IP not found for MIP={}, interface={}, vpnName {}. Skipping adjacency "
 218                                 + "addition.", ip, interfaceName, vpnName);
 219                         return;
 220                     }
 221
 222                     String rd = vpnUtil.getVpnRd(vpnInstName);
 223                     Uint32 label = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME,
 224                         VpnUtil.getNextHopLabelKey(rd != null ? rd : vpnInstName, ip));
 225                     if (label.longValue() == VpnConstants.INVALID_LABEL) {
 226                         LOG.error("Unable to fetch label from Id Manager. Bailing out of adding MIP adjacency {}"
 227                                 + " to vpn interface {} for vpn {}", ip, vpnInterface, vpnInstName);
 228                         return;
 229                     }
 230                     newAdjBuilder = new AdjacencyBuilder().setIpAddress(ip).withKey(new AdjacencyKey(ip))
 231                             .setNextHopIpList(Collections.singletonList(nextHopIp))
 232                             .setAdjacencyType(AdjacencyType.LearntIp);
 233                     if (mipMacAddress != null && !mipMacAddress.equalsIgnoreCase(nextHopMacAddress)) {
 234                         newAdjBuilder.setMacAddress(mipMacAddress);
 235                     }
 236                 }
 237                 adjacencyList.add(newAdjBuilder.build());
 238                 Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencyList);
 239                 VpnInterface newVpnIntf = new VpnInterfaceBuilder(optVpnInterface.get())
 240                         .addAugmentation(Adjacencies.class, aug).build();
 241                 SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfId,
 242                     newVpnIntf, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
 243                 LOG.debug(" Successfully stored subnetroute Adjacency into VpnInterface {}", vpnInterface);
 244             } catch (InterruptedException | ExecutionException e) {
 245                 LOG.error("addMipAdjacency: Failed to read data store for interface {} vpn {} ip {} mac {}",
 246                         vpnInterface, vpnInstName, srcPrefix, mipMacAddress);
 247             } catch (TransactionCommitFailedException e) {
 248                 LOG.error("addMipAdjacency: Failed to commit to data store for interface {} vpn {} ip {} mac {}",
 249                         vpnInterface, vpnInstName, srcPrefix, mipMacAddress);
 250             } finally {
 251                 lock.unlock();
 252             }
 253         }
 254
 255         @Nullable
 256         private String getSubnetId(String vpnInstName, String ip) {
 257             // Check if this IP belongs to a router_interface
 258             VpnPortipToPort vpnPortipToPort =
 259                     vpnUtil.getNeutronPortFromVpnPortFixedIp(vpnInstName, ip);
 260             if (vpnPortipToPort != null && vpnPortipToPort.isSubnetIp()) {
 261                 List<Adjacency> adjacencies =
 262                     vpnUtil.getAdjacenciesForVpnInterfaceFromConfig(vpnPortipToPort.getPortName());
 263                 if (adjacencies != null) {
 264                     for (Adjacency adjacency : adjacencies) {
 265                         if (adjacency.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
 266                             return adjacency.getSubnetId().getValue();
 267                         }
 268                     }
 269                 }
 270             }
 271
 272             // Check if this IP belongs to a router_gateway
 273             List<Uuid> routerIds = vpnUtil.getExternalNetworkRouterIds(new Uuid(vpnInstName));
 274             for (Uuid routerId : routerIds) {
 275                 Uuid subnetId = vpnUtil.getSubnetFromExternalRouterByIp(routerId, ip);
 276                 if (subnetId != null) {
 277                     return subnetId.getValue();
 278                 }
 279             }
 280
 281             // Check if this IP belongs to  external network
 282             String extSubnetId = vpnUtil.getAssociatedExternalSubnet(ip);
 283             if (extSubnetId != null) {
 284                 LOG.info("The IP belongs to extenal subnet {} ", extSubnetId);
 285                 return extSubnetId;
 286             }
 287
 288             return null;
 289         }
 290     }
 291
 292     private class DeleteMipAdjacencyWorker implements Callable<List<? extends ListenableFuture<?>>> {
 293         String vpnName;
 294         String interfaceName;
 295         String ipAddress;
 296
 297         DeleteMipAdjacencyWorker(LearntVpnVipToPortEvent event) {
 298             this.vpnName = event.getVpnName();
 299             this.interfaceName = event.getPortName();
 300             this.ipAddress = event.getSrcFixedip();
 301         }
 302
 303         @Override
 304         public List<ListenableFuture<Void>> call() {
 305             List<ListenableFuture<Void>> futures = new ArrayList<>();
 306             vpnUtil.removeMipAdjAndLearntIp(vpnName, interfaceName,  ipAddress);
 307             return futures;
 308         }
 309
 310     }
 311
 312 }
 313