natservice/impl/src/main/java/org/opendaylight/netvirt/natservice/internal/ExternalNetworksChangeListener.java

   1 /*
   2  * Copyright (c) 2016 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.natservice.internal;
   9
  10 import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
  11
  12 import com.google.common.base.Optional;
  13 import java.math.BigInteger;
  14 import java.util.Collection;
  15 import java.util.Collections;
  16 import java.util.List;
  17 import java.util.concurrent.ExecutionException;
  18 import javax.annotation.PostConstruct;
  19 import javax.inject.Inject;
  20 import javax.inject.Singleton;
  21 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.genius.datastoreutils.AsyncDataTreeChangeListenerBase;
  24 import org.opendaylight.genius.infra.Datastore.Configuration;
  25 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
  26 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
  27 import org.opendaylight.genius.infra.TypedReadWriteTransaction;
  28 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  29 import org.opendaylight.genius.mdsalutil.NwConstants;
  30 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.config.rev170206.NatserviceConfig.NatMode;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.IntextIpMap;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.RouterPorts;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.Ports;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.floating.ip.info.router.ports.ports.InternalToExternalPortMap;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.intext.ip.map.ip.mapping.IpMap;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
  43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 @Singleton
  49 public class ExternalNetworksChangeListener
  50         extends AsyncDataTreeChangeListenerBase<Networks, ExternalNetworksChangeListener> {
  51     private static final Logger LOG = LoggerFactory.getLogger(ExternalNetworksChangeListener.class);
  52     private final DataBroker dataBroker;
  53     private final ManagedNewTransactionRunner txRunner;
  54     private final FloatingIPListener floatingIpListener;
  55     private final ExternalRoutersListener externalRouterListener;
  56     private final OdlInterfaceRpcService interfaceManager;
  57     private final JobCoordinator coordinator;
  58     private final NatMode natMode;
  59
  60     @Inject
  61     public ExternalNetworksChangeListener(final DataBroker dataBroker, final FloatingIPListener floatingIpListener,
  62                                           final ExternalRoutersListener externalRouterListener,
  63                                           final OdlInterfaceRpcService interfaceManager,
  64                                           final NatserviceConfig config,
  65                                           final JobCoordinator coordinator) {
  66         super(Networks.class, ExternalNetworksChangeListener.class);
  67         this.dataBroker = dataBroker;
  68         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
  69         this.floatingIpListener = floatingIpListener;
  70         this.externalRouterListener = externalRouterListener;
  71         this.interfaceManager = interfaceManager;
  72         this.coordinator = coordinator;
  73         if (config != null) {
  74             this.natMode = config.getNatMode();
  75         } else {
  76             this.natMode = NatMode.Controller;
  77         }
  78     }
  79
  80     @Override
  81     @PostConstruct
  82     public void init() {
  83         LOG.info("{} init", getClass().getSimpleName());
  84         registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
  85     }
  86
  87     @Override
  88     protected InstanceIdentifier<Networks> getWildCardPath() {
  89         return InstanceIdentifier.create(ExternalNetworks.class).child(Networks.class);
  90     }
  91
  92     @Override
  93     protected void add(InstanceIdentifier<Networks> identifier, Networks networks) {
  94
  95     }
  96
  97     @Override
  98     protected ExternalNetworksChangeListener getDataTreeChangeListener() {
  99         return ExternalNetworksChangeListener.this;
 100     }
 101
 102     @Override
 103     protected void remove(InstanceIdentifier<Networks> identifier, Networks networks) {
 104         if (identifier == null || networks == null || networks.getRouterIds().isEmpty()) {
 105             LOG.warn("remove : returning without processing since networks/identifier is null: "
 106                 + "identifier: {}, networks: {}", identifier, networks);
 107             return;
 108         }
 109
 110         for (Uuid routerId: networks.getRouterIds()) {
 111             String routerName = routerId.toString();
 112
 113             InstanceIdentifier<RouterToNaptSwitch> routerToNaptSwitchInstanceIdentifier =
 114                     NatUtil.buildNaptSwitchIdentifier(routerName);
 115
 116             MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, routerToNaptSwitchInstanceIdentifier);
 117
 118             LOG.debug("remove : successful deletion of data in napt-switches container");
 119         }
 120     }
 121
 122     @Override
 123     protected void update(InstanceIdentifier<Networks> identifier, Networks original, Networks update) {
 124         //Check for VPN disassociation
 125         Uuid originalVpn = original.getVpnid();
 126         Uuid updatedVpn = update.getVpnid();
 127         coordinator.enqueueJob(NatConstants.NAT_DJC_PREFIX + update.key(),
 128             () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
 129                 if (originalVpn == null && updatedVpn != null) {
 130                     //external network is dis-associated from L3VPN instance
 131                     associateExternalNetworkWithVPN(update, tx);
 132                 } else if (originalVpn != null && updatedVpn == null) {
 133                     //external network is associated with vpn
 134                     disassociateExternalNetworkFromVPN(update, originalVpn.getValue());
 135                     //Remove the SNAT entries
 136                     removeSnatEntries(original, original.getId(), tx);
 137                 }
 138             })), NatConstants.NAT_DJC_MAX_RETRIES);
 139     }
 140
 141     private void removeSnatEntries(Networks original, Uuid networkUuid,
 142         TypedReadWriteTransaction<Configuration> writeFlowInvTx) {
 143         List<Uuid> routerUuids = original.getRouterIds();
 144         for (Uuid routerUuid : routerUuids) {
 145             Long routerId = NatUtil.getVpnId(dataBroker, routerUuid.getValue());
 146             if (routerId == NatConstants.INVALID_ID) {
 147                 LOG.error("removeSnatEntries : Invalid routerId returned for routerName {}", routerUuid.getValue());
 148                 return;
 149             }
 150             Collection<String> externalIps = NatUtil.getExternalIpsForRouter(dataBroker,routerId);
 151             if (natMode == NatMode.Controller) {
 152                 externalRouterListener.handleDisableSnatInternetVpn(routerUuid.getValue(), routerId, networkUuid,
 153                         externalIps, original.getVpnid().getValue(), writeFlowInvTx);
 154             }
 155         }
 156     }
 157
 158     private void associateExternalNetworkWithVPN(Networks network, TypedReadWriteTransaction<Configuration> confTx) {
 159         List<Uuid> routerIds = network.getRouterIds();
 160         for (Uuid routerId : routerIds) {
 161             //long router = NatUtil.getVpnId(dataBroker, routerId.getValue());
 162
 163             InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
 164             Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
 165                 routerPortsId);
 166             if (!optRouterPorts.isPresent()) {
 167                 LOG.debug("associateExternalNetworkWithVPN : Could not read Router Ports data object with id: {} "
 168                         + "to handle associate ext nw {}", routerId, network.getId());
 169                 continue;
 170             }
 171             RouterPorts routerPorts = optRouterPorts.get();
 172             List<Ports> interfaces = routerPorts.getPorts();
 173             for (Ports port : interfaces) {
 174                 String portName = port.getPortName();
 175                 BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
 176                 if (dpnId.equals(BigInteger.ZERO)) {
 177                     LOG.debug("associateExternalNetworkWithVPN : DPN not found for {}, "
 178                             + "skip handling of ext nw {} association", portName, network.getId());
 179                     continue;
 180                 }
 181                 List<InternalToExternalPortMap> intExtPortMapList = port.getInternalToExternalPortMap();
 182                 for (InternalToExternalPortMap ipMap : intExtPortMapList) {
 183                     //remove all VPN related entries
 184                     floatingIpListener.createNATFlowEntries(dpnId, portName, routerId.getValue(), network.getId(),
 185                             ipMap, confTx);
 186                 }
 187             }
 188         }
 189
 190         // SNAT
 191         for (Uuid routerId : routerIds) {
 192             LOG.debug("associateExternalNetworkWithVPN() : for routerId {}",  routerId);
 193             Uuid networkId = network.getId();
 194             if (networkId == null) {
 195                 LOG.error("associateExternalNetworkWithVPN : networkId is null for the router ID {}", routerId);
 196                 return;
 197             }
 198             final String vpnName = network.getVpnid().getValue();
 199             if (vpnName == null) {
 200                 LOG.error("associateExternalNetworkWithVPN : No VPN associated with ext nw {} for router {}",
 201                         networkId, routerId);
 202                 return;
 203             }
 204
 205             BigInteger dpnId = new BigInteger("0");
 206             InstanceIdentifier<RouterToNaptSwitch> routerToNaptSwitch =
 207                 NatUtil.buildNaptSwitchRouterIdentifier(routerId.getValue());
 208             Optional<RouterToNaptSwitch> rtrToNapt =
 209                 MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, routerToNaptSwitch);
 210             if (rtrToNapt.isPresent()) {
 211                 dpnId = rtrToNapt.get().getPrimarySwitchId();
 212             }
 213             LOG.debug("associateExternalNetworkWithVPN : got primarySwitch as dpnId{} ", dpnId);
 214             if (dpnId == null || dpnId.equals(BigInteger.ZERO)) {
 215                 LOG.warn("associateExternalNetworkWithVPN : primary napt Switch not found for router {} on dpn: {}",
 216                     routerId, dpnId);
 217                 return;
 218             }
 219
 220             Long routerIdentifier = NatUtil.getVpnId(dataBroker, routerId.getValue());
 221             InstanceIdentifierBuilder<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice
 222                 .rev160111.intext.ip.map.IpMapping> idBuilder =
 223                 InstanceIdentifier.builder(IntextIpMap.class)
 224                     .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
 225                         .intext.ip.map.IpMapping.class,
 226                         new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
 227                             .intext.ip.map.IpMappingKey(routerIdentifier));
 228             InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
 229                 .intext.ip.map.IpMapping> id = idBuilder.build();
 230             Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111
 231                 .intext.ip.map.IpMapping> ipMapping = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
 232             if (ipMapping.isPresent()) {
 233                 List<IpMap> ipMaps = ipMapping.get().getIpMap();
 234                 for (IpMap ipMap : ipMaps) {
 235                     String externalIp = ipMap.getExternalIp();
 236                     LOG.debug("associateExternalNetworkWithVPN : Calling advToBgpAndInstallFibAndTsFlows for dpnId {},"
 237                         + "vpnName {} and externalIp {}", dpnId, vpnName, externalIp);
 238                     if (natMode == NatMode.Controller) {
 239                         externalRouterListener.advToBgpAndInstallFibAndTsFlows(dpnId, NwConstants.INBOUND_NAPT_TABLE,
 240                                 vpnName, routerIdentifier, routerId.getValue(),
 241                                 externalIp, network.getId(), null /* external-router */,
 242                                 confTx);
 243                     }
 244                 }
 245             } else {
 246                 LOG.warn("associateExternalNetworkWithVPN : No ipMapping present fot the routerId {}", routerId);
 247             }
 248
 249             long vpnId = NatUtil.getVpnId(dataBroker, vpnName);
 250             // Install 47 entry to point to 21
 251             if (natMode == NatMode.Controller) {
 252                 externalRouterListener.installNaptPfibEntriesForExternalSubnets(routerId.getValue(), dpnId,
 253                         confTx);
 254                 if (vpnId != -1) {
 255                     LOG.debug("associateExternalNetworkWithVPN : Calling externalRouterListener installNaptPfibEntry "
 256                             + "for dpnId {} and vpnId {}", dpnId, vpnId);
 257                     externalRouterListener.installNaptPfibEntry(dpnId, vpnId, confTx);
 258                 }
 259             }
 260         }
 261
 262     }
 263
 264     private void disassociateExternalNetworkFromVPN(Networks network, String vpnName) {
 265         List<Uuid> routerIds = network.getRouterIds();
 266
 267         for (Uuid routerId : routerIds) {
 268             InstanceIdentifier<RouterPorts> routerPortsId = NatUtil.getRouterPortsId(routerId.getValue());
 269             Optional<RouterPorts> optRouterPorts = MDSALUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION,
 270                 routerPortsId);
 271             if (!optRouterPorts.isPresent()) {
 272                 LOG.debug("disassociateExternalNetworkFromVPN : Could not read Router Ports data object with id: {} "
 273                         + "to handle disassociate ext nw {}", routerId, network.getId());
 274                 continue;
 275             }
 276             RouterPorts routerPorts = optRouterPorts.get();
 277             List<Ports> interfaces = routerPorts.getPorts();
 278             try {
 279                 txRunner.callWithNewReadWriteTransactionAndSubmit(CONFIGURATION, tx -> {
 280                     for (Ports port : interfaces) {
 281                         String portName = port.getPortName();
 282                         BigInteger dpnId = NatUtil.getDpnForInterface(interfaceManager, portName);
 283                         if (dpnId.equals(BigInteger.ZERO)) {
 284                             LOG.debug("disassociateExternalNetworkFromVPN : DPN not found for {},"
 285                                     + "skip handling of ext nw {} disassociation", portName, network.getId());
 286                             continue;
 287                         }
 288                         List<InternalToExternalPortMap> intExtPortMapList = port.getInternalToExternalPortMap();
 289                         for (InternalToExternalPortMap intExtPortMap : intExtPortMapList) {
 290                             floatingIpListener.removeNATFlowEntries(dpnId, portName, vpnName, routerId.getValue(),
 291                                     intExtPortMap, tx);
 292                         }
 293                     }
 294                 }).get();
 295             } catch (ExecutionException | InterruptedException e) {
 296                 LOG.error("Error writing to datastore {}", e);
 297             }
 298         }
 299     }
 300 }