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