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