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.collect.Lists;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16 import java.util.ArrayList;
  17 import java.util.Collections;
  18 import java.util.List;
  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.mdsalutil.NWUtil;
  36 import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
  37 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  38 import org.opendaylight.mdsal.eos.binding.api.Entity;
  39 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipCandidateRegistration;
  40 import org.opendaylight.mdsal.eos.binding.api.EntityOwnershipService;
  41 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
  42 import org.opendaylight.netvirt.vpnmanager.VpnConstants;
  43 import org.opendaylight.netvirt.vpnmanager.VpnUtil;
  44 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  45 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
  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             try {
 181                 synchronized (vpnInterface.intern()) {
 182                     Optional<VpnInterface> optVpnInterface = SingleTransactionDataBroker.syncReadOptional(dataBroker,
 183                             LogicalDatastoreType.CONFIGURATION, vpnIfId);
 184                     if (!optVpnInterface.isPresent()) {
 185                         LOG.error("Config VpnInterface not found for interface={}", interfaceName);
 186                         return;
 187                     }
 188                     Adjacencies configAdjacencies = optVpnInterface.get().augmentation(Adjacencies.class);
 189                     List<Adjacency> adjacencyList =
 190                             configAdjacencies == null ? Lists.newArrayList() : configAdjacencies.getAdjacency();
 191
 192                     String ip = VpnUtil.getIpPrefix(srcPrefix);
 193                     AdjacencyBuilder newAdjBuilder;
 194                     if (interfaceManager.isExternalInterface(vpnInterface)) {
 195                         String subnetId = getSubnetId(vpnInstName, dstPrefix);
 196                         if (subnetId == null) {
 197                             LOG.trace("Can't find corresponding subnet for src IP {}, src MAC {}, dst IP {},"
 198                                     + "  in VPN {}", srcPrefix, mipMacAddress, dstPrefix, vpnInstName);
 199                             return;
 200                         }
 201                         newAdjBuilder = new AdjacencyBuilder().setIpAddress(ip).withKey(new AdjacencyKey(ip))
 202                                 .setAdjacencyType(AdjacencyType.PrimaryAdjacency).setMacAddress(mipMacAddress)
 203                                 .setSubnetId(new Uuid(subnetId)).setPhysNetworkFunc(true);
 204                     } else {
 205                         String nextHopIp = null;
 206                         String nextHopMacAddress = null;
 207                         for (Adjacency adjacency : adjacencyList) {
 208                             if (adjacency.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
 209                                 if (adjacency.getIpAddress().equals(ip)) {
 210                                     LOG.error("The MIP {} is already present as a primary adjacency for interface {}."
 211                                             + "Skipping adjacency addition.", ip, interfaceName);
 212                                     return;
 213                                 } else if (NWUtil.getEtherTypeFromIpPrefix(ip) == NWUtil
 214                                         .getEtherTypeFromIpPrefix(adjacency.getIpAddress())) {
 215                                     nextHopIp = adjacency.getIpAddress().split("/")[0];
 216                                     nextHopMacAddress = adjacency.getMacAddress();
 217                                     break;
 218                                 }
 219                             }
 220                         }
 221                         if (nextHopIp == null) {
 222                             LOG.error("Next Hop IP not found for MIP={}, interface={}, vpnName {}. Skipping adjacency "
 223                                     + "addition.", ip, interfaceName, vpnName);
 224                             return;
 225                         }
 226
 227                         String rd = vpnUtil.getVpnRd(vpnInstName);
 228                         long label = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME,
 229                                 VpnUtil.getNextHopLabelKey(rd != null ? rd : vpnInstName, ip));
 230                         if (label == 0) {
 231                             LOG.error("Unable to fetch label from Id Manager. Bailing out of adding MIP adjacency {}"
 232                                     + " to vpn interface {} for vpn {}", ip, vpnInterface, vpnInstName);
 233                             return;
 234                         }
 235                         newAdjBuilder = new AdjacencyBuilder().setIpAddress(ip).withKey(new AdjacencyKey(ip))
 236                                 .setNextHopIpList(Collections.singletonList(nextHopIp))
 237                                 .setAdjacencyType(AdjacencyType.LearntIp);
 238                         if (mipMacAddress != null && !mipMacAddress.equalsIgnoreCase(nextHopMacAddress)) {
 239                             newAdjBuilder.setMacAddress(mipMacAddress);
 240                         }
 241                     }
 242                     adjacencyList.add(newAdjBuilder.build());
 243                     Adjacencies aug = VpnUtil.getVpnInterfaceAugmentation(adjacencyList);
 244                     VpnInterface newVpnIntf = new VpnInterfaceBuilder(optVpnInterface.get())
 245                             .addAugmentation(Adjacencies.class, aug).build();
 246                     SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIfId,
 247                             newVpnIntf, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
 248                     LOG.debug(" Successfully stored subnetroute Adjacency into VpnInterface {}", vpnInterface);
 249                 }
 250             } catch (ReadFailedException e) {
 251                 LOG.error("addMipAdjacency: Failed to read data store for interface {} vpn {} ip {} mac {}",
 252                         vpnInterface, vpnInstName, srcPrefix, mipMacAddress);
 253             } catch (TransactionCommitFailedException e) {
 254                 LOG.error("addMipAdjacency: Failed to commit to data store for interface {} vpn {} ip {} mac {}",
 255                         vpnInterface, vpnInstName, srcPrefix, mipMacAddress);
 256             }
 257         }
 258
 259         @Nullable
 260         private String getSubnetId(String vpnInstName, String ip) {
 261             // Check if this IP belongs to a router_interface
 262             VpnPortipToPort vpnPortipToPort =
 263                     vpnUtil.getNeutronPortFromVpnPortFixedIp(vpnInstName, ip);
 264             if (vpnPortipToPort != null && vpnPortipToPort.isSubnetIp()) {
 265                 List<Adjacency> adjacencies = requireNonNullElse(vpnUtil.getAdjacenciesForVpnInterfaceFromConfig(
 266                         vpnPortipToPort.getPortName()), emptyList());
 267                 for (Adjacency adjacency : adjacencies) {
 268                     if (adjacency.getAdjacencyType() == AdjacencyType.PrimaryAdjacency) {
 269                         return adjacency.getSubnetId().getValue();
 270                     }
 271                 }
 272             }
 273
 274             // Check if this IP belongs to a router_gateway
 275             List<Uuid> routerIds = vpnUtil.getExternalNetworkRouterIds(new Uuid(vpnInstName));
 276             for (Uuid routerId : routerIds) {
 277                 Uuid subnetId = vpnUtil.getSubnetFromExternalRouterByIp(routerId, ip);
 278                 if (subnetId != null) {
 279                     return subnetId.getValue();
 280                 }
 281             }
 282
 283             // Check if this IP belongs to  external network
 284             String extSubnetId = vpnUtil.getAssociatedExternalSubnet(ip);
 285             if (extSubnetId != null) {
 286                 LOG.info("The IP belongs to extenal subnet {} ", extSubnetId);
 287                 return extSubnetId;
 288             }
 289
 290             return null;
 291         }
 292     }
 293
 294     private class DeleteMipAdjacencyWorker implements Callable<List<ListenableFuture<Void>>> {
 295         String vpnName;
 296         String interfaceName;
 297         String ipAddress;
 298
 299         DeleteMipAdjacencyWorker(LearntVpnVipToPortEvent event) {
 300             this.vpnName = event.getVpnName();
 301             this.interfaceName = event.getPortName();
 302             this.ipAddress = event.getSrcFixedip();
 303         }
 304
 305         @Override
 306         public List<ListenableFuture<Void>> call() {
 307             List<ListenableFuture<Void>> futures = new ArrayList<>();
 308             vpnUtil.removeMipAdjAndLearntIp(vpnName, interfaceName,  ipAddress);
 309             return futures;
 310         }
 311
 312     }
 313
 314 }
 315