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