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