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