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