vpnservice/neutronvpn/neutronvpn-impl/src/main/java/org/opendaylight/netvirt/neutronvpn/NeutronvpnManager.java

   1 /*
   2  * Copyright (c) 2015 - 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.neutronvpn;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.util.concurrent.SettableFuture;
  12
  13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  14 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  15 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
  16 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  17 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  18 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  19 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  20 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  21 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargets;
  22 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargetsBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
  24 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetKey;
  26 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  27 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.vpn.instance.Ipv4FamilyBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksInput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateNetworksOutputBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.AssociateRouterInput;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateL3VPNInput;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateL3VPNOutput;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.CreateL3VPNOutputBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DeleteL3VPNInput;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DeleteL3VPNOutput;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DeleteL3VPNOutputBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateNetworksInput;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateNetworksOutput;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateNetworksOutputBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.DissociateRouterInput;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetFixedIPsForNeutronPortInput;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetFixedIPsForNeutronPortOutput;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetFixedIPsForNeutronPortOutputBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetL3VPNInput;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetL3VPNInputBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetL3VPNOutput;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.GetL3VPNOutputBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.L3vpnInstance;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronvpnService;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterAssociatedToVpn;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterAssociatedToVpnBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterDisassociatedFromVpn;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterDisassociatedFromVpnBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetAddedToVpnBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetDeletedFromVpnBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.SubnetUpdatedInVpnBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.VpnMaps;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfaces;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfacesBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfacesKey;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.Interfaces;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.InterfacesBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.InterfacesKey;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyKey;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.ext.rev150712.NetworkL3Extension;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInstances;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstanceKey;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.createl3vpn.input.L3vpn;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.getl3vpn.output.L3vpnInstances;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.getl3vpn.output.L3vpnInstancesBuilder;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapBuilder;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMap;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.vpnmaps.VpnMapKey;
 101 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 102 import org.opendaylight.yangtools.yang.common.RpcError;
 103 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
 104 import org.opendaylight.yangtools.yang.common.RpcResult;
 105 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 106
 107 import java.util.EventListener;
 108
 109 import org.slf4j.Logger;
 110 import org.slf4j.LoggerFactory;
 111
 112 import java.util.ArrayList;
 113 import java.util.Arrays;
 114 import java.util.List;
 115 import java.util.concurrent.ExecutionException;
 116 import java.util.concurrent.Future;
 117
 118 public class NeutronvpnManager implements NeutronvpnService, AutoCloseable, EventListener {
 119
 120     private static final Logger logger = LoggerFactory.getLogger(NeutronvpnManager.class);
 121     private final DataBroker broker;
 122     private LockManagerService lockManager;
 123     private NeutronvpnNatManager nvpnNatManager;
 124     IMdsalApiManager mdsalUtil;
 125     private NotificationPublishService notificationPublishService;
 126     private NotificationService notificationService;
 127     private NeutronFloatingToFixedIpMappingChangeListener floatingIpMapListener;
 128     Boolean isExternalVpn;
 129
 130     /**
 131      * @param db           - dataBroker reference
 132      * @param mdsalManager - MDSAL Util API access
 133      */
 134     public NeutronvpnManager(final DataBroker db, IMdsalApiManager mdsalManager,NotificationPublishService notiPublishService,
 135                              NotificationService notiService, NeutronvpnNatManager vpnNatMgr,
 136                              NeutronFloatingToFixedIpMappingChangeListener neutronFloatingToFixedIpMappingChangeListener) {
 137         broker = db;
 138         mdsalUtil = mdsalManager;
 139         nvpnNatManager = vpnNatMgr;
 140         notificationPublishService = notiPublishService;
 141         notificationService = notiService;
 142         floatingIpMapListener = neutronFloatingToFixedIpMappingChangeListener;
 143     }
 144
 145     public void setLockManager(LockManagerService lockManager) {
 146         this.lockManager = lockManager;
 147     }
 148
 149     @Override
 150     public void close() throws Exception {
 151         logger.info("Neutron VPN Manager Closed");
 152     }
 153
 154     protected Subnetmap updateSubnetNode(Uuid subnetId, String subnetIp, Uuid tenantId, Uuid networkId, Uuid routerId,
 155                                          Uuid vpnId) {
 156         Subnetmap subnetmap = null;
 157         SubnetmapBuilder builder = null;
 158         boolean isLockAcquired = false;
 159         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
 160                 child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
 161         try {
 162             Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 163             logger.debug("updating Subnet :read: ");
 164             if (sn.isPresent()) {
 165                 builder = new SubnetmapBuilder(sn.get());
 166                 logger.debug("updating Subnet :existing: ");
 167             } else {
 168                 builder = new SubnetmapBuilder().setKey(new SubnetmapKey(subnetId)).setId(subnetId);
 169                 logger.debug("updating Subnet :new: ");
 170             }
 171
 172             if (subnetIp != null) {
 173                 builder.setSubnetIp(subnetIp);
 174             }
 175             if (routerId != null) {
 176                 builder.setRouterId(routerId);
 177             }
 178             if (networkId != null) {
 179                 builder.setNetworkId(networkId);
 180             }
 181             if (vpnId != null) {
 182                 builder.setVpnId(vpnId);
 183             }
 184             if (tenantId != null) {
 185                 builder.setTenantId(tenantId);
 186             }
 187
 188             subnetmap = builder.build();
 189             isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 190             logger.debug("Creating/Updating subnetMap node: {} ", subnetId.getValue());
 191             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
 192         } catch (Exception e) {
 193             logger.error("Updation of subnetMap failed for node: {}", subnetId.getValue());
 194         } finally {
 195             if (isLockAcquired) {
 196                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 197             }
 198         }
 199         return subnetmap;
 200     }
 201
 202     protected Subnetmap removeFromSubnetNode(Uuid subnetId, Uuid networkId, Uuid routerId, Uuid vpnId, Uuid portId) {
 203         Subnetmap subnetmap = null;
 204         boolean isLockAcquired = false;
 205         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
 206                 child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
 207         try {
 208             Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 209             if (sn.isPresent()) {
 210                 SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
 211                 if (routerId != null) {
 212                     builder.setRouterId(null);
 213                 }
 214                 if (networkId != null) {
 215                     builder.setNetworkId(null);
 216                 }
 217                 if (vpnId != null) {
 218                     builder.setVpnId(null);
 219                 }
 220                 if (portId != null && builder.getPortList() != null) {
 221                     List<Uuid> portList = builder.getPortList();
 222                     portList.remove(portId);
 223                     builder.setPortList(portList);
 224                 }
 225
 226                 subnetmap = builder.build();
 227                 isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 228                 logger.debug("Removing from existing subnetmap node: {} ", subnetId.getValue());
 229                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
 230             } else {
 231                 logger.warn("removing from non-existing subnetmap node: {} ", subnetId.getValue());
 232             }
 233         } catch (Exception e) {
 234             logger.error("Removal from subnetmap failed for node: {}", subnetId.getValue());
 235         } finally {
 236             if (isLockAcquired) {
 237                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 238             }
 239         }
 240         return subnetmap;
 241     }
 242
 243     protected Subnetmap updateSubnetmapNodeWithPorts(Uuid subnetId, Uuid portId, Uuid directPortId) {
 244         Subnetmap subnetmap = null;
 245         boolean isLockAcquired = false;
 246         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
 247                 new SubnetmapKey(subnetId)).build();
 248         try {
 249             Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 250             if (sn.isPresent()) {
 251                 SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
 252                 if (null != portId) {
 253                     List<Uuid> portList = builder.getPortList();
 254                     if (null == portList) {
 255                         portList = new ArrayList<Uuid>();
 256                     }
 257                     portList.add(portId);
 258                     builder.setPortList(portList);
 259                     logger.debug("Updating existing subnetmap node {} with port {}", subnetId.getValue(),
 260                             portId.getValue());
 261                 }
 262                 if (null != directPortId) {
 263                     List<Uuid> directPortList = builder.getDirectPortList();
 264                     if (null == directPortList) {
 265                         directPortList = new ArrayList<Uuid>();
 266                     }
 267                     directPortList.add(directPortId);
 268                     builder.setDirectPortList(directPortList);
 269                     logger.debug("Updating existing subnetmap node {} with port {}", subnetId.getValue(),
 270                             directPortId.getValue());
 271                 }
 272                 subnetmap = builder.build();
 273                 isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 274                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
 275             } else {
 276                 logger.error("Trying to update non-existing subnetmap node {} ", subnetId.getValue());
 277             }
 278         } catch (Exception e) {
 279             logger.error("Updating port list of a given subnetMap failed for node: {} with exception{}",
 280                     subnetId.getValue(), e);
 281         } finally {
 282             if (isLockAcquired) {
 283                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 284             }
 285         }
 286         return subnetmap;
 287     }
 288
 289     protected Subnetmap removePortsFromSubnetmapNode(Uuid subnetId, Uuid portId, Uuid directPortId) {
 290         Subnetmap subnetmap = null;
 291         boolean isLockAcquired = false;
 292         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
 293                 new SubnetmapKey(subnetId)).build();
 294         try {
 295             Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 296             if (sn.isPresent()) {
 297                 SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
 298                 if (null != portId && null != builder.getPortList()) {
 299                     List<Uuid> portList = builder.getPortList();
 300                     portList.remove(portId);
 301                     builder.setPortList(portList);
 302                     logger.debug("Removing port {} from existing subnetmap node: {} ", portId.getValue(),
 303                             subnetId.getValue());
 304                 }
 305                 if (null != directPortId && null != builder.getDirectPortList()) {
 306                     List<Uuid> directPortList = builder.getDirectPortList();
 307                     directPortList.remove(directPortId);
 308                     builder.setDirectPortList(directPortList);
 309                     logger.debug("Removing direct port {} from existing subnetmap node: {} ", directPortId.getValue(),
 310                             subnetId.getValue());
 311                 }
 312                 subnetmap = builder.build();
 313                 isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 314                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
 315             } else {
 316                 logger.error("Trying to remove port from non-existing subnetmap node {}", subnetId.getValue());
 317             }
 318         } catch (Exception e) {
 319             logger.error("Removing a port from port list of a subnetmap failed for node: {} with expection {}",
 320                     subnetId.getValue(), e);
 321         } finally {
 322             if (isLockAcquired) {
 323                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 324             }
 325         }
 326         return subnetmap;
 327     }
 328
 329     protected void deleteSubnetMapNode(Uuid subnetId) {
 330         boolean isLockAcquired = false;
 331         InstanceIdentifier<Subnetmap> subnetMapIdentifier = InstanceIdentifier.builder(Subnetmaps.class)
 332                 .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
 333         logger.debug("removing subnetMap node: {} ", subnetId.getValue());
 334         try {
 335             isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 336             MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, subnetMapIdentifier);
 337         } catch (Exception e) {
 338             logger.error("Delete subnetMap node failed for subnet : {} ", subnetId.getValue());
 339         } finally {
 340             if (isLockAcquired) {
 341                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 342             }
 343         }
 344     }
 345
 346     private void updateVpnInstanceNode(String vpnName, List<String> rd, List<String> irt, List<String> ert) {
 347
 348         VpnInstanceBuilder builder = null;
 349         List<VpnTarget> vpnTargetList = new ArrayList<>();
 350         boolean isLockAcquired = false;
 351         InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
 352                 child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 353         try {
 354             Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 355                     vpnIdentifier);
 356             logger.debug("Creating/Updating a new vpn-instance node: {} ", vpnName);
 357             if (optionalVpn.isPresent()) {
 358                 builder = new VpnInstanceBuilder(optionalVpn.get());
 359                 logger.debug("updating existing vpninstance node");
 360             } else {
 361                 builder = new VpnInstanceBuilder().setKey(new VpnInstanceKey(vpnName)).setVpnInstanceName(vpnName);
 362             }
 363             if (irt != null && !irt.isEmpty()) {
 364                 if (ert != null && !ert.isEmpty()) {
 365                     List<String> commonRT = new ArrayList<>(irt);
 366                     commonRT.retainAll(ert);
 367
 368                     for (String common : commonRT) {
 369                         irt.remove(common);
 370                         ert.remove(common);
 371                         VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(common)).setVrfRTValue
 372                                 (common).setVrfRTType(VpnTarget.VrfRTType.Both).build();
 373                         vpnTargetList.add(vpnTarget);
 374                     }
 375                 }
 376                 for (String importRT : irt) {
 377                     VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(importRT)).setVrfRTValue
 378                             (importRT).setVrfRTType(VpnTarget.VrfRTType.ImportExtcommunity).build();
 379                     vpnTargetList.add(vpnTarget);
 380                 }
 381             }
 382
 383             if (ert != null && !ert.isEmpty()) {
 384                 for (String exportRT : ert) {
 385                     VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(exportRT)).setVrfRTValue
 386                             (exportRT).setVrfRTType(VpnTarget.VrfRTType.ExportExtcommunity).build();
 387                     vpnTargetList.add(vpnTarget);
 388                 }
 389             }
 390
 391             VpnTargets vpnTargets = new VpnTargetsBuilder().setVpnTarget(vpnTargetList).build();
 392
 393             Ipv4FamilyBuilder ipv4vpnBuilder = new Ipv4FamilyBuilder().setVpnTargets(vpnTargets);
 394
 395             if (rd != null && !rd.isEmpty()) {
 396                 ipv4vpnBuilder.setRouteDistinguisher(rd.get(0));
 397             }
 398
 399             VpnInstance newVpn = builder.setIpv4Family(ipv4vpnBuilder.build()).build();
 400             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnName);
 401             logger.debug("Creating/Updating vpn-instance for {} ", vpnName);
 402             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier, newVpn);
 403         } catch (Exception e) {
 404             logger.error("Update VPN Instance node failed for node: {} {} {} {}", vpnName, rd, irt, ert);
 405         } finally {
 406             if (isLockAcquired) {
 407                 NeutronvpnUtils.unlock(lockManager, vpnName);
 408             }
 409         }
 410     }
 411
 412     private void deleteVpnMapsNode(Uuid vpnid) {
 413         boolean isLockAcquired = false;
 414         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 415                 .child(VpnMap.class, new VpnMapKey(vpnid)).build();
 416         logger.debug("removing vpnMaps node: {} ", vpnid.getValue());
 417         try {
 418             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnid.getValue());
 419             MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
 420         } catch (Exception e) {
 421             logger.error("Delete vpnMaps node failed for vpn : {} ", vpnid.getValue());
 422         } finally {
 423             if (isLockAcquired) {
 424                 NeutronvpnUtils.unlock(lockManager, vpnid.getValue());
 425             }
 426         }
 427     }
 428
 429     private void updateVpnMaps(Uuid vpnId, String name, Uuid router, Uuid tenantId, List<Uuid> networks) {
 430         VpnMapBuilder builder;
 431         boolean isLockAcquired = false;
 432         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 433                 .child(VpnMap.class, new VpnMapKey(vpnId)).build();
 434         try {
 435             Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 436                     vpnMapIdentifier);
 437             if (optionalVpnMap.isPresent()) {
 438                 builder = new VpnMapBuilder(optionalVpnMap.get());
 439             } else {
 440                 builder = new VpnMapBuilder().setKey(new VpnMapKey(vpnId)).setVpnId(vpnId);
 441             }
 442
 443             if (name != null) {
 444                 builder.setName(name);
 445             }
 446             if (tenantId != null) {
 447                 builder.setTenantId(tenantId);
 448             }
 449             if (router != null) {
 450                 builder.setRouterId(router);
 451             }
 452             if (networks != null) {
 453                 List<Uuid> nwList = builder.getNetworkIds();
 454                 if (nwList == null) {
 455                     nwList = new ArrayList<>();
 456                 }
 457                 nwList.addAll(networks);
 458                 builder.setNetworkIds(nwList);
 459             }
 460
 461             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 462             logger.debug("Creating/Updating vpnMaps node: {} ", vpnId.getValue());
 463             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, builder.build());
 464             logger.debug("VPNMaps DS updated for VPN {} ", vpnId.getValue());
 465         } catch (Exception e) {
 466             logger.error("UpdateVpnMaps failed for node: {} ", vpnId.getValue());
 467         } finally {
 468             if (isLockAcquired) {
 469                 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 470             }
 471         }
 472     }
 473
 474     private void clearFromVpnMaps(Uuid vpnId, Uuid routerId, List<Uuid> networkIds) {
 475         boolean isLockAcquired = false;
 476         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 477                 .child(VpnMap.class, new VpnMapKey(vpnId)).build();
 478         Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 479                 vpnMapIdentifier);
 480         if (optionalVpnMap.isPresent()) {
 481             VpnMap vpnMap = optionalVpnMap.get();
 482             VpnMapBuilder vpnMapBuilder = new VpnMapBuilder(vpnMap);
 483             if (routerId != null) {
 484                 if (vpnMap.getNetworkIds() == null && routerId.equals(vpnMap.getVpnId())) {
 485                     try {
 486                         // remove entire node in case of internal VPN
 487                         isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 488                         logger.debug("removing vpnMaps node: {} ", vpnId);
 489                         MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
 490                     } catch (Exception e) {
 491                         logger.error("Deletion of vpnMaps node failed for vpn {}", vpnId.getValue());
 492                     } finally {
 493                         if (isLockAcquired) {
 494                             NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 495                         }
 496                     }
 497                     return;
 498                 }
 499                 vpnMapBuilder.setRouterId(null);
 500             }
 501             if (networkIds != null) {
 502                 List<Uuid> vpnNw = vpnMap.getNetworkIds();
 503                 for (Uuid nw : networkIds) {
 504                     vpnNw.remove(nw);
 505                 }
 506                 if (vpnNw.isEmpty()) {
 507                     logger.debug("setting networks null in vpnMaps node: {} ", vpnId.getValue());
 508                     vpnMapBuilder.setNetworkIds(null);
 509                 } else {
 510                     vpnMapBuilder.setNetworkIds(vpnNw);
 511                 }
 512             }
 513
 514             try {
 515                 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 516                 logger.debug("clearing from vpnMaps node: {} ", vpnId.getValue());
 517                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, vpnMapBuilder.build
 518                         ());
 519             } catch (Exception e) {
 520                 logger.error("Clearing from vpnMaps node failed for vpn {}", vpnId.getValue());
 521             } finally {
 522                 if (isLockAcquired) {
 523                     NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 524                 }
 525             }
 526         } else {
 527             logger.error("VPN : {} not found", vpnId.getValue());
 528         }
 529         logger.debug("Clear from VPNMaps DS successful for VPN {} ", vpnId.getValue());
 530     }
 531
 532     private void deleteVpnInstance(Uuid vpnId) {
 533         boolean isLockAcquired = false;
 534         InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
 535                 child(VpnInstance.class, new VpnInstanceKey(vpnId.getValue())).build();
 536         try {
 537             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 538             logger.debug("Deleting vpnInstance {}", vpnId.getValue());
 539             MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
 540         } catch (Exception e) {
 541             logger.error("Deletion of VPNInstance node failed for VPN {}", vpnId.getValue());
 542         } finally {
 543             if (isLockAcquired) {
 544                 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 545             }
 546         }
 547     }
 548
 549     protected void createVpnInterface(Uuid vpnId, Port port) {
 550         boolean isLockAcquired = false;
 551         if (vpnId == null || port == null) {
 552             return;
 553         }
 554         String infName = port.getUuid().getValue();
 555         List<Adjacency> adjList = new ArrayList<>();
 556         InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
 557
 558         // find router associated to vpn
 559         Uuid routerId = NeutronvpnUtils.getRouterforVpn(broker, vpnId);
 560         Router rtr = null;
 561         if (routerId != null) {
 562             rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
 563         }
 564         // find all subnets to which this port is associated
 565         List<FixedIps> ips = port.getFixedIps();
 566         // create adjacency list
 567         for (FixedIps ip : ips) {
 568             // create vm adjacency
 569             StringBuilder IpPrefixBuild = new StringBuilder(ip.getIpAddress().getIpv4Address().getValue());
 570             String IpPrefix = IpPrefixBuild.append("/32").toString();
 571             Adjacency vmAdj = new AdjacencyBuilder().setKey(new AdjacencyKey(IpPrefix)).setIpAddress(IpPrefix)
 572                     .setMacAddress(port.getMacAddress().getValue()).build();
 573             adjList.add(vmAdj);
 574             // create extra route adjacency
 575             if (rtr != null && rtr.getRoutes() != null) {
 576                 List<Routes> routeList = rtr.getRoutes();
 577                 List<Adjacency> erAdjList = addAdjacencyforExtraRoute(routeList, false, infName);
 578                 if (erAdjList != null && !erAdjList.isEmpty()) {
 579                     adjList.addAll(erAdjList);
 580                 }
 581             }
 582         }
 583         // create vpn-interface on this neutron port
 584         Adjacencies adjs = new AdjacenciesBuilder().setAdjacency(adjList).build();
 585         VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName)).
 586                 setName(infName).setVpnInstanceName(vpnId.getValue()).addAugmentation(Adjacencies.class, adjs);
 587         VpnInterface vpnIf = vpnb.build();
 588
 589         try {
 590             isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 591             logger.debug("Creating vpn interface {}", vpnIf);
 592             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
 593         } catch (Exception ex) {
 594             logger.error("Creation of vpninterface {} failed due to {}", infName, ex);
 595         } finally {
 596             if (isLockAcquired) {
 597                 NeutronvpnUtils.unlock(lockManager, infName);
 598             }
 599         }
 600     }
 601
 602     protected void deleteVpnInterface(Port port) {
 603
 604         if (port != null) {
 605             boolean isLockAcquired = false;
 606             String infName = port.getUuid().getValue();
 607             InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
 608
 609             try {
 610                 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 611                 logger.debug("Deleting vpn interface {}", infName);
 612                 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
 613             } catch (Exception ex) {
 614                 logger.error("Deletion of vpninterface {} failed due to {}", infName, ex);
 615             } finally {
 616                 if (isLockAcquired) {
 617                     NeutronvpnUtils.unlock(lockManager, infName);
 618                 }
 619             }
 620         }
 621     }
 622
 623     protected void updateVpnInterface(Uuid vpnId, Port port) {
 624         if (vpnId == null || port == null) {
 625             return;
 626         }
 627         boolean isLockAcquired = false;
 628         String infName = port.getUuid().getValue();
 629         InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
 630         try {
 631             Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
 632                     .CONFIGURATION, vpnIfIdentifier);
 633             if (optionalVpnInterface.isPresent()) {
 634                 VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get());
 635                 VpnInterface vpnIf = vpnIfBuilder.setVpnInstanceName(vpnId.getValue()).build();
 636                 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 637                 logger.debug("Updating vpn interface {}", vpnIf);
 638                 MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
 639             } else {
 640                 logger.error("VPN Interface {} not found", infName);
 641             }
 642         } catch (Exception ex) {
 643             logger.error("Updation of vpninterface {} failed due to {}", infName, ex);
 644         } finally {
 645             if (isLockAcquired) {
 646                 NeutronvpnUtils.unlock(lockManager, infName);
 647             }
 648         }
 649     }
 650
 651     public void createL3InternalVpn(Uuid vpn, String name, Uuid tenant, List<String> rd, List<String> irt, List<String> ert,
 652                                     Uuid router, List<Uuid> networks) {
 653
 654         // Update VPN Instance node
 655         updateVpnInstanceNode(vpn.getValue(), rd, irt, ert);
 656
 657         // Update local vpn-subnet DS
 658         updateVpnMaps(vpn, name, router, tenant, networks);
 659
 660         if (router != null) {
 661             Uuid existingVpn = NeutronvpnUtils.getVpnForRouter(broker, router, true);
 662             if (existingVpn != null) {
 663                 List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, router);
 664                 if (routerSubnets != null) {
 665                     // Update the router interfaces alone and exit
 666                     for (Uuid subnetId : routerSubnets) {
 667                         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
 668                                 child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
 669                         Optional<Subnetmap> snMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 670                         if (snMap.isPresent()) {
 671                             Subnetmap sn = snMap.get();
 672                             List<Uuid> portList = sn.getPortList();
 673                             if (portList != null) {
 674                                 for (Uuid port : sn.getPortList()) {
 675                                     addToNeutronRouterInterfacesMap(router, port.getValue());
 676                                 }
 677                             }
 678                         }
 679                     }
 680                 }
 681                 logger.info("Creation of Internal L3VPN skipped for VPN {} due to router {} already associated to " +
 682                         "external VPN {}", vpn.getValue(), router.getValue(), existingVpn.getValue());
 683                 return;
 684             }
 685             associateRouterToInternalVpn(vpn, router);
 686         }
 687     }
 688
 689     public void createL3Vpn(Uuid vpn, String name, Uuid tenant, List<String> rd, List<String> irt, List<String> ert,
 690                             Uuid router, List<Uuid> networks) {
 691
 692         // Update VPN Instance node
 693         updateVpnInstanceNode(vpn.getValue(), rd, irt, ert);
 694
 695         // Update local vpn-subnet DS
 696         updateVpnMaps(vpn, name, router, tenant, networks);
 697
 698         if (router != null) {
 699             associateRouterToVpn(vpn, router);
 700         }
 701         if (networks != null) {
 702             associateNetworksToVpn(vpn, networks);
 703         }
 704     }
 705
 706     @Override
 707     public Future<RpcResult<CreateL3VPNOutput>> createL3VPN(CreateL3VPNInput input) {
 708
 709         CreateL3VPNOutputBuilder opBuilder = new CreateL3VPNOutputBuilder();
 710         SettableFuture<RpcResult<CreateL3VPNOutput>> result = SettableFuture.create();
 711         List<RpcError> errorList = new ArrayList<>();
 712         int failurecount = 0;
 713         int warningcount = 0;
 714
 715         List<L3vpn> vpns = input.getL3vpn();
 716         for (L3vpn vpn : vpns) {
 717             RpcError error = null;
 718             String msg;
 719             if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) {
 720                 msg = String.format("Creation of L3VPN failed for VPN %s due to absence of RD/iRT/eRT input",
 721                         vpn.getId().getValue());
 722                 logger.warn(msg);
 723                 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 724                 errorList.add(error);
 725                 warningcount++;
 726                 continue;
 727             }
 728             if (vpn.getRouteDistinguisher().size() > 1) {
 729                 msg = String.format("Creation of L3VPN failed for VPN %s due to multiple RD input %s",
 730                         vpn.getId().getValue(), vpn.getRouteDistinguisher());
 731                 logger.warn(msg);
 732                 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 733                 errorList.add(error);
 734                 warningcount++;
 735                 continue;
 736             }
 737             if (vpn.getRouterId() != null) {
 738                 if (NeutronvpnUtils.getNeutronRouter(broker, vpn.getRouterId()) == null) {
 739                     msg = String.format("Creation of L3VPN failed for VPN %s due to router not found %s",
 740                             vpn.getId().getValue(), vpn.getRouterId().getValue());
 741                     logger.warn(msg);
 742                     error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 743                     errorList.add(error);
 744                     warningcount++;
 745                     continue;
 746                 }
 747                 Uuid vpnId = NeutronvpnUtils.getVpnForRouter(broker, vpn.getRouterId(), true);
 748                 if (vpnId != null) {
 749                     msg = String.format("Creation of L3VPN failed for VPN %s due to router %s already associated to " +
 750                             "another VPN %s", vpn.getId().getValue(), vpn.getRouterId().getValue(), vpnId.getValue());
 751                     logger.warn(msg);
 752                     error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 753                     errorList.add(error);
 754                     warningcount++;
 755                     continue;
 756                 }
 757             }
 758             if (vpn.getNetworkIds() != null) {
 759                 for (Uuid nw : vpn.getNetworkIds()) {
 760                     Network network = NeutronvpnUtils.getNeutronNetwork(broker, nw);
 761                     Uuid vpnId = NeutronvpnUtils.getVpnForNetwork(broker, nw);
 762                     if (network == null) {
 763                         msg = String.format("Creation of L3VPN failed for VPN %s due to network not found %s",
 764                                 vpn.getId().getValue(), nw.getValue());
 765                         logger.warn(msg);
 766                         error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 767                         errorList.add(error);
 768                         warningcount++;
 769                     } else if (vpnId != null) {
 770                         msg = String.format("Creation of L3VPN failed for VPN %s due to network %s already associated" +
 771                                 " to another VPN %s", vpn.getId().getValue(), nw.getValue(), vpnId.getValue());
 772                         logger.warn(msg);
 773                         error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 774                         errorList.add(error);
 775                         warningcount++;
 776                     }
 777                 }
 778                 if (error != null) {
 779                     continue;
 780                 }
 781             }
 782             try {
 783                 createL3Vpn(vpn.getId(), vpn.getName(), vpn.getTenantId(), vpn.getRouteDistinguisher(),
 784                         vpn.getImportRT(), vpn.getExportRT(), vpn.getRouterId(), vpn.getNetworkIds());
 785             } catch (Exception ex) {
 786                 msg = String.format("Creation of L3VPN failed for VPN %s", vpn.getId().getValue());
 787                 logger.error(msg, ex);
 788                 error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
 789                 errorList.add(error);
 790                 failurecount++;
 791             }
 792         }
 793         // if at least one succeeds; result is success
 794         // if none succeeds; result is failure
 795         if (failurecount + warningcount == vpns.size()) {
 796             result.set(RpcResultBuilder.<CreateL3VPNOutput>failed().withRpcErrors(errorList).build());
 797         } else {
 798             List<String> errorResponseList = new ArrayList<>();
 799             if (!errorList.isEmpty()) {
 800                 for (RpcError rpcError : errorList) {
 801                     String errorResponse = String.format("ErrorType: " + rpcError.getErrorType() + ", " + "ErrorTag: " +
 802                             rpcError.getTag() + ", " + "ErrorMessage: " + rpcError.getMessage());
 803                     errorResponseList.add(errorResponse);
 804                 }
 805             } else {
 806                 errorResponseList.add("Operation successful with no errors");
 807             }
 808             opBuilder.setResponse(errorResponseList);
 809             result.set(RpcResultBuilder.<CreateL3VPNOutput>success().withResult(opBuilder.build()).build());
 810         }
 811         return result;
 812     }
 813
 814     @Override
 815     public Future<RpcResult<GetL3VPNOutput>> getL3VPN(GetL3VPNInput input) {
 816
 817         GetL3VPNOutputBuilder opBuilder = new GetL3VPNOutputBuilder();
 818         SettableFuture<RpcResult<GetL3VPNOutput>> result = SettableFuture.create();
 819         Uuid inputVpnId = input.getId();
 820         List<VpnInstance> vpns = new ArrayList<>();
 821
 822         try {
 823             if (inputVpnId == null) {
 824                 // get all vpns
 825                 InstanceIdentifier<VpnInstances> vpnsIdentifier =
 826                         InstanceIdentifier.builder(VpnInstances.class).build();
 827                 Optional<VpnInstances> optionalVpns = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 828                         vpnsIdentifier);
 829                 if (optionalVpns.isPresent() && optionalVpns.get().getVpnInstance() != null) {
 830                     for (VpnInstance vpn : optionalVpns.get().getVpnInstance()) {
 831                         // eliminating internal VPNs from getL3VPN output
 832                         if (vpn.getIpv4Family().getRouteDistinguisher() != null) {
 833                             vpns.add(vpn);
 834                         }
 835                     }
 836                 } else {
 837                     // No VPN present
 838                     result.set(RpcResultBuilder.<GetL3VPNOutput>failed()
 839                             .withWarning(ErrorType.PROTOCOL, "", "No VPN is present").build());
 840                     return result;
 841                 }
 842             } else {
 843                 String name = inputVpnId.getValue();
 844                 InstanceIdentifier<VpnInstance> vpnIdentifier =
 845                         InstanceIdentifier.builder(VpnInstances.class)
 846                                 .child(VpnInstance.class, new VpnInstanceKey(name)).build();
 847                 // read VpnInstance Info
 848                 Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 849                         vpnIdentifier);
 850                 if (optionalVpn.isPresent()) {
 851                     vpns.add(optionalVpn.get());
 852                 } else {
 853                     String message = String.format("GetL3VPN failed because VPN %s is not present", name);
 854                     logger.error(message);
 855                     result.set(RpcResultBuilder.<GetL3VPNOutput>failed()
 856                             .withWarning(ErrorType.PROTOCOL, "invalid-value", message).build());
 857                 }
 858             }
 859             List<L3vpnInstances> l3vpnList = new ArrayList<>();
 860             for (VpnInstance vpnInstance : vpns) {
 861                 Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
 862                 // create VpnMaps id
 863                 InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap
 864                         .class, new VpnMapKey(vpnId)).build();
 865                 L3vpnInstancesBuilder l3vpn = new L3vpnInstancesBuilder();
 866
 867                 List<String> rd = Arrays.asList(vpnInstance.getIpv4Family().getRouteDistinguisher().split(","));
 868                 List<VpnTarget> vpnTargetList = vpnInstance.getIpv4Family().getVpnTargets().getVpnTarget();
 869
 870                 List<String> ertList = new ArrayList<>();
 871                 List<String> irtList = new ArrayList<>();
 872
 873                 for (VpnTarget vpnTarget : vpnTargetList) {
 874                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
 875                         ertList.add(vpnTarget.getVrfRTValue());
 876                     }
 877                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ImportExtcommunity) {
 878                         irtList.add(vpnTarget.getVrfRTValue());
 879                     }
 880                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.Both) {
 881                         ertList.add(vpnTarget.getVrfRTValue());
 882                         irtList.add(vpnTarget.getVrfRTValue());
 883                     }
 884                 }
 885
 886                 l3vpn.setId(vpnId).setRouteDistinguisher(rd).setImportRT(irtList).setExportRT(ertList);
 887                 Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 888                         vpnMapIdentifier);
 889                 if (optionalVpnMap.isPresent()) {
 890                     VpnMap vpnMap = optionalVpnMap.get();
 891                     l3vpn.setRouterId(vpnMap.getRouterId()).setNetworkIds(vpnMap.getNetworkIds())
 892                             .setTenantId(vpnMap.getTenantId()).setName(vpnMap.getName());
 893                 }
 894                 l3vpnList.add(l3vpn.build());
 895             }
 896
 897             opBuilder.setL3vpnInstances(l3vpnList);
 898             result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
 899
 900         } catch (Exception ex) {
 901             String message = String.format("GetL3VPN failed due to %s", ex.getMessage());
 902             logger.error(message, ex);
 903             result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION, message).build());
 904         }
 905         return result;
 906     }
 907
 908     @Override
 909     public Future<RpcResult<DeleteL3VPNOutput>> deleteL3VPN(DeleteL3VPNInput input) {
 910
 911         DeleteL3VPNOutputBuilder opBuilder = new DeleteL3VPNOutputBuilder();
 912         SettableFuture<RpcResult<DeleteL3VPNOutput>> result = SettableFuture.create();
 913         List<RpcError> errorList = new ArrayList<>();
 914
 915         int failurecount = 0;
 916         int warningcount = 0;
 917         List<Uuid> vpns = input.getId();
 918         for (Uuid vpn : vpns) {
 919             RpcError error;
 920             String msg;
 921             try {
 922                 InstanceIdentifier<VpnInstance> vpnIdentifier =
 923                         InstanceIdentifier.builder(VpnInstances.class)
 924                                 .child(VpnInstance.class, new VpnInstanceKey(vpn.getValue())).build();
 925                 Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 926                         vpnIdentifier);
 927                 if (optionalVpn.isPresent()) {
 928                     removeL3Vpn(vpn);
 929                 } else {
 930                     msg = String.format("VPN with vpnid: %s does not exist", vpn.getValue());
 931                     logger.warn(msg);
 932                     error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-value", msg);
 933                     errorList.add(error);
 934                     warningcount++;
 935                 }
 936             } catch (Exception ex) {
 937                 msg = String.format("Deletion of L3VPN failed when deleting for uuid %s", vpn.getValue());
 938                 logger.error(msg, ex);
 939                 error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
 940                 errorList.add(error);
 941                 failurecount++;
 942             }
 943         }
 944         // if at least one succeeds; result is success
 945         // if none succeeds; result is failure
 946         if (failurecount + warningcount == vpns.size()) {
 947             result.set(RpcResultBuilder.<DeleteL3VPNOutput>failed().withRpcErrors(errorList).build());
 948         } else {
 949             List<String> errorResponseList = new ArrayList<>();
 950             if (!errorList.isEmpty()) {
 951                 for (RpcError rpcError : errorList) {
 952                     String errorResponse = String.format("ErrorType: " + rpcError.getErrorType() + ", " + "ErrorTag: " +
 953                             rpcError.getTag() + ", " + "ErrorMessage: " + rpcError.getMessage());
 954                     errorResponseList.add(errorResponse);
 955                 }
 956             } else {
 957                 errorResponseList.add("Operation successful with no errors");
 958             }
 959             opBuilder.setResponse(errorResponseList);
 960             result.set(RpcResultBuilder.<DeleteL3VPNOutput>success().withResult(opBuilder.build()).build());
 961         }
 962         return result;
 963     }
 964
 965     protected void addSubnetToVpn(Uuid vpnId, Uuid subnet) {
 966         logger.debug("Adding subnet {} to vpn {}", subnet.getValue(), vpnId.getValue());
 967         Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId);
 968         boolean isLockAcquired = false;
 969         String lockName = vpnId.getValue() + subnet.getValue();
 970         String elanInstanceName = sn.getNetworkId().getValue();
 971         InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class).child
 972                 (ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
 973         Optional<ElanInstance> elanInstance = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 974                 elanIdentifierId);
 975         //TODO: Cache it in add so can reuse it in update and delete. Best would be to cache in some ElanUtils
 976         long elanTag = elanInstance.get().getElanTag();
 977         Uuid routerId = NeutronvpnUtils.getVpnMap(broker, vpnId).getRouterId();
 978         if (vpnId.equals(routerId)) {
 979             isExternalVpn = false;
 980         } else {
 981             isExternalVpn = true;
 982         }
 983         try {
 984             isLockAcquired = NeutronvpnUtils.lock(lockManager, lockName);
 985             checkAndPublishSubnetAddNotification(subnet, sn.getSubnetIp(), vpnId.getValue(), isExternalVpn, elanTag);
 986             logger.debug("Subnet added to Vpn notification sent");
 987         }catch (Exception e){
 988             logger.error("Subnet added to Vpn notification failed",e);
 989         }finally {
 990             if (isLockAcquired) {
 991                 NeutronvpnUtils.unlock(lockManager, lockName);
 992             }
 993         }
 994         // Check if there are ports on this subnet and add corresponding vpn-interfaces
 995         List<Uuid> portList = sn.getPortList();
 996         if (portList != null) {
 997             for (Uuid port : sn.getPortList()) {
 998                 logger.debug("adding vpn-interface for port {}", port.getValue());
 999                 createVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(broker, port));
1000                 if (routerId != null) {
1001                     addToNeutronRouterInterfacesMap(routerId, port.getValue());
1002                 }
1003             }
1004         }
1005     }
1006
1007     protected void updateVpnForSubnet(Uuid vpnId, Uuid subnet, boolean isBeingAssociated) {
1008         logger.debug("Updating VPN {} for subnet {}", vpnId.getValue(), subnet.getValue());
1009         Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId);
1010         boolean isLockAcquired = false;
1011         String lockName = vpnId.getValue() + subnet.getValue();
1012         String elanInstanceName = sn.getNetworkId().getValue();
1013         InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class).child
1014                 (ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
1015         Optional<ElanInstance> elanInstance = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
1016                 elanIdentifierId);
1017         long elanTag = elanInstance.get().getElanTag();
1018         try {
1019             isLockAcquired = NeutronvpnUtils.lock(lockManager, lockName);
1020             checkAndPublishSubnetUpdNotification(subnet, sn.getSubnetIp(), vpnId.getValue(), isBeingAssociated,
1021                     elanTag);
1022             logger.debug("Subnet updated in Vpn notification sent");
1023         } catch (Exception e) {
1024             logger.error("Subnet updated in Vpn notification failed", e);
1025         }finally {
1026             if (isLockAcquired) {
1027                 NeutronvpnUtils.unlock(lockManager, lockName);
1028             }
1029         }
1030         // Check for ports on this subnet and update association of corresponding vpn-interfaces to external vpn
1031         List<Uuid> portList = sn.getPortList();
1032         if (portList != null) {
1033             for (Uuid port : sn.getPortList()) {
1034                 logger.debug("Updating vpn-interface for port {}", port.getValue());
1035                 updateVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(broker, port));
1036             }
1037         }
1038     }
1039
1040     InstanceIdentifier<RouterInterfaces> getRouterInterfacesId(Uuid routerId) {
1041         return InstanceIdentifier.builder(RouterInterfacesMap.class)
1042                 .child(RouterInterfaces.class, new RouterInterfacesKey(routerId)).build();
1043     }
1044     void addToNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) {
1045         InstanceIdentifier<RouterInterfaces> routerInterfacesId =  getRouterInterfacesId(routerId);
1046         Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId);
1047         Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId(interfaceName).build();
1048         if(optRouterInterfaces.isPresent()) {
1049             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId.child(Interfaces.class, new InterfacesKey(interfaceName)), routerInterface);
1050         } else {
1051             RouterInterfacesBuilder builder = new RouterInterfacesBuilder().setRouterId(routerId);
1052             List<Interfaces> interfaces = new ArrayList<>();
1053             interfaces.add(routerInterface);
1054             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId, builder.setInterfaces(interfaces).build());
1055         }
1056     }
1057
1058     void removeFromNeutronRouterInterfacesMap(Uuid routerId, String interfaceName) {
1059         InstanceIdentifier<RouterInterfaces> routerInterfacesId =  getRouterInterfacesId(routerId);
1060         Optional<RouterInterfaces> optRouterInterfaces = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId);
1061         Interfaces routerInterface = new InterfacesBuilder().setKey(new InterfacesKey(interfaceName)).setInterfaceId(interfaceName).build();
1062         if(optRouterInterfaces.isPresent()) {
1063             RouterInterfaces routerInterfaces = optRouterInterfaces.get();
1064             List<Interfaces> interfaces = routerInterfaces.getInterfaces();
1065             if(interfaces != null && interfaces.remove(routerInterface)) {
1066                 if(interfaces.isEmpty()) {
1067                     MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId);
1068                 } else {
1069                     MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, routerInterfacesId.child(Interfaces.class, new InterfacesKey(interfaceName)));
1070                 }
1071             }
1072         }
1073     }
1074
1075     protected List<Adjacency> addAdjacencyforExtraRoute(List<Routes> routeList, boolean rtrUp, String vpnifname) {
1076         List<Adjacency> adjList = new ArrayList<>();
1077         for (Routes route : routeList) {
1078             if (route != null && route.getNexthop() != null && route.getDestination() != null) {
1079                 boolean isLockAcquired = false;
1080                 String nextHop = String.valueOf(route.getNexthop().getValue());
1081                 String destination = String.valueOf(route.getDestination().getValue());
1082
1083                 String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
1084                 logger.trace("Adding extra route with nexthop {}, destination {}, infName {}", nextHop,
1085                         destination, infName);
1086                 Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIp(nextHop).setKey
1087                         (new AdjacencyKey(destination)).build();
1088                 if (!rtrUp) {
1089                     if (infName.equals(vpnifname)) {
1090                         adjList.add(erAdj);
1091                     }
1092                     continue;
1093                 }
1094                 InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
1095                         child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
1096                 try {
1097                     Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
1098                             .CONFIGURATION, vpnIfIdentifier);
1099                     if (optionalVpnInterface.isPresent()) {
1100                         Adjacencies erAdjs = new AdjacenciesBuilder().setAdjacency(Arrays.asList(erAdj)).build();
1101                         VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName))
1102                                 .addAugmentation(Adjacencies.class, erAdjs).build();
1103                         isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
1104                         logger.debug("Adding extra route {}", route);
1105                         MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
1106                     } else {
1107                         logger.error("VM adjacency for interface {} not present ; cannot add extra route adjacency",
1108                                 infName);
1109                     }
1110                 } catch (Exception e) {
1111                     logger.error("exception in adding extra route: {}" + e);
1112                 } finally {
1113                     if (isLockAcquired) {
1114                         NeutronvpnUtils.unlock(lockManager, infName);
1115                     }
1116                 }
1117             } else {
1118                 logger.error("Incorrect input received for extra route. {}", route);
1119             }
1120         }
1121         return adjList;
1122     }
1123
1124     protected void removeAdjacencyforExtraRoute(List<Routes> routeList) {
1125         for (Routes route : routeList) {
1126             if (route != null && route.getNexthop() != null && route.getDestination() != null) {
1127                 boolean isLockAcquired = false;
1128                 String nextHop = String.valueOf(route.getNexthop().getValue());
1129                 String destination = String.valueOf(route.getDestination().getValue());
1130
1131                 String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
1132                 logger.trace("Removing extra route with nexthop {}, destination {}, infName {}", nextHop,
1133                         destination, infName);
1134                 InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
1135                         child(VpnInterface.class, new VpnInterfaceKey(infName)).augmentation(Adjacencies.class)
1136                         .child(Adjacency.class, new AdjacencyKey(destination)).build();
1137                 try {
1138                     isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
1139                     MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
1140                     logger.trace("extra route {} deleted successfully", route);
1141                 } catch (Exception e) {
1142                     logger.error("exception in deleting extra route: {}" + e);
1143                 } finally {
1144                     if (isLockAcquired) {
1145                         NeutronvpnUtils.unlock(lockManager, infName);
1146                     }
1147                 }
1148             } else {
1149                 logger.error("Incorrect input received for extra route. {}", route);
1150             }
1151         }
1152     }
1153
1154     protected void removeL3Vpn(Uuid id) {
1155         // read VPNMaps
1156         VpnMap vpnMap = NeutronvpnUtils.getVpnMap(broker, id);
1157         Uuid router = vpnMap.getRouterId();
1158         // dissociate router
1159         if (router != null) {
1160             dissociateRouterFromVpn(id, router);
1161         }
1162         // dissociate networks
1163         if (!id.equals(router)) {
1164             dissociateNetworksFromVpn(id, vpnMap.getNetworkIds());
1165         }
1166         // remove entire vpnMaps node
1167         deleteVpnMapsNode(id);
1168
1169         // remove vpn-instance
1170         deleteVpnInstance(id);
1171     }
1172
1173     protected void removeSubnetFromVpn(Uuid vpnId, Uuid subnet) {
1174         logger.debug("Removing subnet {} from vpn {}", subnet.getValue(), vpnId.getValue());
1175         Subnetmap sn = NeutronvpnUtils.getSubnetmap(broker, subnet);
1176         boolean isLockAcquired = false;
1177         String lockName = vpnId.getValue() + subnet.getValue();
1178         String elanInstanceName = sn.getNetworkId().getValue();
1179         InstanceIdentifier<ElanInstance> elanIdentifierId = InstanceIdentifier.builder(ElanInstances.class).child
1180                 (ElanInstance.class, new ElanInstanceKey(elanInstanceName)).build();
1181         Optional<ElanInstance> elanInstance = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
1182                 elanIdentifierId);
1183         long elanTag = elanInstance.get().getElanTag();
1184         Uuid routerId = NeutronvpnUtils.getVpnMap(broker, vpnId).getRouterId();
1185         if (vpnId.equals(routerId)) {
1186             isExternalVpn = false;
1187         } else {
1188             isExternalVpn = true;
1189         }
1190         try {
1191             isLockAcquired = NeutronvpnUtils.lock(lockManager, lockName);
1192             checkAndPublishSubnetDelNotification(subnet, sn.getSubnetIp(), vpnId.getValue(), isExternalVpn, elanTag);
1193             logger.debug("Subnet removed from Vpn notification sent");
1194         }catch (Exception e){
1195             logger.error("Subnet removed from Vpn notification failed",e);
1196         }finally {
1197             if (isLockAcquired) {
1198                 NeutronvpnUtils.unlock(lockManager, lockName);
1199             }
1200         }
1201         if (sn != null) {
1202             // Check if there are ports on this subnet; remove corresponding vpn-interfaces
1203             List<Uuid> portList = sn.getPortList();
1204             if (portList != null) {
1205                 for (Uuid port : sn.getPortList()) {
1206                     logger.debug("removing vpn-interface for port {}", port.getValue());
1207                     deleteVpnInterface(NeutronvpnUtils.getNeutronPort(broker, port));
1208                     if (routerId != null) {
1209                         removeFromNeutronRouterInterfacesMap(routerId, port.getValue());
1210                     }
1211                 }
1212             }
1213             // update subnet-vpn association
1214             removeFromSubnetNode(subnet, null, null, vpnId, null);
1215         } else {
1216             logger.warn("Subnetmap for subnet {} not found", subnet.getValue());
1217         }
1218     }
1219
1220     protected void associateRouterToVpn(Uuid vpnId, Uuid routerId) {
1221         updateVpnMaps(vpnId, null, routerId, null, null);
1222         logger.debug("Updating association of subnets to external vpn {}", vpnId.getValue());
1223         List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
1224 //      if (!vpnId.equals(routerId)) {
1225         if (routerSubnets != null) {
1226             for (Uuid subnetId : routerSubnets) {
1227                 updateVpnForSubnet(vpnId, subnetId, true);
1228             }
1229         }
1230         try {
1231             checkAndPublishRouterAssociatedtoVpnNotification(routerId, vpnId);
1232             logger.debug("notification upon association of router {} to VPN {} published", routerId.getValue(),
1233                     vpnId.getValue());
1234         } catch (Exception e) {
1235             logger.error("publishing of notification upon association of router {} to VPN {} failed : ", routerId
1236                     .getValue(), vpnId.getValue(), e);
1237         }
1238     }
1239
1240     protected void dissociatefixedIPFromFloatingIP(String fixedNeutronPortName) {
1241         floatingIpMapListener.dissociatefixedIPFromFloatingIP(fixedNeutronPortName);
1242     }
1243
1244     protected void associateRouterToInternalVpn(Uuid vpnId, Uuid routerId) {
1245         List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
1246         logger.debug("Adding subnets to internal vpn {}", vpnId.getValue());
1247         for (Uuid subnet : routerSubnets) {
1248             addSubnetToVpn(vpnId, subnet);
1249         }
1250     }
1251
1252     protected void dissociateRouterFromVpn(Uuid vpnId, Uuid routerId) {
1253
1254         List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
1255         if (routerSubnets != null) {
1256             for (Uuid subnetId : routerSubnets) {
1257                 logger.debug("Updating association of subnets to internal vpn {}", routerId.getValue());
1258                 updateVpnForSubnet(routerId, subnetId,false);
1259             }
1260         }
1261         clearFromVpnMaps(vpnId, routerId, null);
1262         try {
1263             checkAndPublishRouterDisassociatedFromVpnNotification(routerId, vpnId);
1264             logger.debug("notification upon disassociation of router {} from VPN {} published", routerId.getValue(),
1265                     vpnId.getValue());
1266         } catch (Exception e) {
1267             logger.error("publishing of notification upon disassociation of router {} from VPN {} failed : ", routerId
1268                     .getValue(), vpnId.getValue(), e);
1269         }
1270     }
1271
1272     protected List<String> associateNetworksToVpn(Uuid vpn, List<Uuid> networks) {
1273
1274         List<String> failedNwList = new ArrayList<String>();
1275         List<Uuid> passedNwList = new ArrayList<>();
1276         if (!networks.isEmpty()) {
1277             // process corresponding subnets for VPN
1278             for (Uuid nw : networks) {
1279                 Network network = NeutronvpnUtils.getNeutronNetwork(broker, nw);
1280                 Uuid vpnId = NeutronvpnUtils.getVpnForNetwork(broker, nw);
1281                 if (network == null) {
1282                     failedNwList.add(String.format("network %s not found", nw.getValue()));
1283                 } else if (vpnId != null) {
1284                     failedNwList.add(String.format("network %s already associated to another VPN %s", nw.getValue(),
1285                             vpnId.getValue()));
1286                 } else {
1287                     List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
1288                     logger.debug("Adding network subnets...{}", networkSubnets);
1289                     if (networkSubnets != null) {
1290                         for (Uuid subnet : networkSubnets) {
1291                             // check if subnet added as router interface to some router
1292                             Uuid subnetVpnId = NeutronvpnUtils.getVpnForSubnet(broker, subnet);
1293                             if (subnetVpnId == null) {
1294                                 addSubnetToVpn(vpn, subnet);
1295                                 passedNwList.add(nw);
1296                             } else {
1297                                 failedNwList.add(String.format("subnet %s already added as router interface bound to " +
1298                                         "internal/external VPN %s", subnet.getValue (), subnetVpnId.getValue()));
1299                             }
1300                         }
1301                     }
1302                     if (network.getAugmentation(NetworkL3Extension.class) != null && network.getAugmentation
1303                             (NetworkL3Extension.class).isExternal()) {
1304                         nvpnNatManager.addExternalNetworkToVpn(network, vpn);
1305                     }
1306                 }
1307             }
1308             updateVpnMaps(vpn, null, null, null, passedNwList);
1309         }
1310         return failedNwList;
1311     }
1312
1313     protected List<String> dissociateNetworksFromVpn(Uuid vpn, List<Uuid> networks) {
1314
1315         List<String> failedNwList = new ArrayList<String>();
1316         List<Uuid> passedNwList = new ArrayList<>();
1317         if (networks != null && !networks.isEmpty()) {
1318             // process corresponding subnets for VPN
1319             for (Uuid nw : networks) {
1320                 Network network = NeutronvpnUtils.getNeutronNetwork(broker, nw);
1321                 if (network == null) {
1322                     failedNwList.add(String.format("network %s not found", nw.getValue()));
1323                 } else {
1324                     Uuid vpnId = NeutronvpnUtils.getVpnForNetwork(broker, nw);
1325                     if (vpn.equals(vpnId)) {
1326                         List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
1327                         logger.debug("Removing network subnets...");
1328                         if (networkSubnets != null) {
1329                             for (Uuid subnet : networkSubnets) {
1330                                 removeSubnetFromVpn(vpn, subnet);
1331                                 passedNwList.add(nw);
1332                             }
1333                         }
1334                     } else {
1335                         if (vpnId == null) {
1336                             failedNwList.add(String.format("input network %s not associated to any vpn yet", nw
1337                                     .getValue()));
1338                         } else {
1339                             failedNwList.add(String.format("input network %s associated to a another vpn %s instead " +
1340                                     "of the one given as input", nw.getValue(), vpnId.getValue()));
1341                         }
1342                     }
1343                     if (network.getAugmentation(NetworkL3Extension.class).isExternal()) {
1344                         nvpnNatManager.removeExternalNetworkFromVpn(network);
1345                     }
1346                 }
1347             }
1348             clearFromVpnMaps(vpn, null, passedNwList);
1349         }
1350         return failedNwList;
1351     }
1352
1353     @Override
1354     public Future<RpcResult<AssociateNetworksOutput>> associateNetworks(AssociateNetworksInput input) {
1355
1356         AssociateNetworksOutputBuilder opBuilder = new AssociateNetworksOutputBuilder();
1357         SettableFuture<RpcResult<AssociateNetworksOutput>> result = SettableFuture.create();
1358         logger.debug("associateNetworks {}", input);
1359         StringBuilder returnMsg = new StringBuilder();
1360         Uuid vpnId = input.getVpnId();
1361
1362         try {
1363             if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1364                 List<Uuid> netIds = input.getNetworkId();
1365                 if (netIds != null && !netIds.isEmpty()) {
1366                     List<String> failed = associateNetworksToVpn(vpnId, netIds);
1367                     if (!failed.isEmpty()) {
1368                         returnMsg.append(failed);
1369                     }
1370                 }
1371             } else {
1372                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1373             }
1374             if (returnMsg.length() != 0) {
1375                 String message = String.format("associate Networks to vpn %s failed due to %s", vpnId.getValue(),
1376                         returnMsg);
1377                 logger.error(message);
1378                 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1379                         message);
1380                 opBuilder.setResponse(errorResponse);
1381                 result.set(RpcResultBuilder.<AssociateNetworksOutput>success().withResult(opBuilder.build()).build());
1382             } else {
1383                 result.set(RpcResultBuilder.<AssociateNetworksOutput>success().build());
1384             }
1385         } catch (Exception ex) {
1386             String message = String.format("associate Networks to vpn %s failed due to %s", input.getVpnId().getValue(),
1387                     ex.getMessage());
1388             logger.error(message, ex);
1389             result.set(RpcResultBuilder.<AssociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
1390                     .build());
1391         }
1392         logger.debug("associateNetworks returns..");
1393         return result;
1394     }
1395
1396     @Override
1397     public Future<RpcResult<Void>> associateRouter(AssociateRouterInput input) {
1398
1399         SettableFuture<RpcResult<Void>> result = SettableFuture.create();
1400         logger.debug("associateRouter {}", input);
1401         StringBuilder returnMsg = new StringBuilder();
1402         Uuid vpnId = input.getVpnId();
1403         Uuid routerId = input.getRouterId();
1404         try {
1405             if (routerId != null && vpnId != null) {
1406                 Router rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
1407                 VpnMap vpnMap = NeutronvpnUtils.getVpnMap(broker, vpnId);
1408                 if (rtr != null && vpnMap != null) {
1409                     Uuid extVpnId = NeutronvpnUtils.getVpnForRouter(broker, routerId, true);
1410                     if (vpnMap.getRouterId() != null) {
1411                         returnMsg.append("vpn ").append(vpnId.getValue()).append(" already associated to router ")
1412                                 .append(vpnMap.getRouterId().getValue());
1413                     } else if (extVpnId != null) {
1414                         returnMsg.append("router ").append(routerId.getValue()).append(" already associated to " +
1415                                 "another VPN ").append(extVpnId.getValue());
1416                     } else {
1417                         associateRouterToVpn(vpnId, routerId);
1418                     }
1419                 } else {
1420                     returnMsg.append("router not found : ").append(routerId.getValue());
1421                 }
1422             } else {
1423                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1424             }
1425             if (returnMsg.length() != 0) {
1426                 String message = String.format("associate router to vpn %s failed due to %s", routerId.getValue(),
1427                         returnMsg);
1428                 logger.error(message);
1429                 result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
1430                         .build());
1431             } else {
1432                 result.set(RpcResultBuilder.<Void>success().build());
1433             }
1434         } catch (Exception ex) {
1435             String message = String.format("associate router %s to vpn %s failed due to %s", routerId.getValue(),
1436                     vpnId.getValue(), ex.getMessage());
1437             logger.error(message, ex);
1438             result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
1439         }
1440         logger.debug("associateRouter returns..");
1441         return result;
1442     }
1443
1444     @Override
1445     public Future<RpcResult<DissociateNetworksOutput>> dissociateNetworks(DissociateNetworksInput input) {
1446
1447         DissociateNetworksOutputBuilder opBuilder = new DissociateNetworksOutputBuilder();
1448         SettableFuture<RpcResult<DissociateNetworksOutput>> result = SettableFuture.create();
1449
1450         logger.debug("dissociateNetworks {}", input);
1451         StringBuilder returnMsg = new StringBuilder();
1452         Uuid vpnId = input.getVpnId();
1453
1454         try {
1455             if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1456                 List<Uuid> netIds = input.getNetworkId();
1457                 if (netIds != null && !netIds.isEmpty()) {
1458                     List<String> failed = dissociateNetworksFromVpn(vpnId, netIds);
1459                     if (!failed.isEmpty()) {
1460                         returnMsg.append(failed);
1461                     }
1462                 }
1463             } else {
1464                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1465             }
1466             if (returnMsg.length() != 0) {
1467                 String message = String.format("dissociate Networks to vpn %s failed due to %s", vpnId.getValue(),
1468                         returnMsg);
1469                 logger.error(message);
1470                 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1471                         message);
1472                 opBuilder.setResponse(errorResponse);
1473                 result.set(RpcResultBuilder.<DissociateNetworksOutput>success().withResult(opBuilder.build()).build());
1474             } else {
1475                 result.set(RpcResultBuilder.<DissociateNetworksOutput>success().build());
1476             }
1477         } catch (Exception ex) {
1478             String message = String.format("dissociate Networks to vpn %s failed due to %s", input.getVpnId().
1479                     getValue(), ex.getMessage());
1480             logger.error(message, ex);
1481             result.set(RpcResultBuilder.<DissociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
1482                     .build());
1483         }
1484         logger.debug("dissociateNetworks returns..");
1485         return result;
1486     }
1487
1488     @Override
1489     public Future<RpcResult<Void>> dissociateRouter(DissociateRouterInput input) {
1490
1491         SettableFuture<RpcResult<Void>> result = SettableFuture.create();
1492
1493         logger.debug("dissociateRouter {}", input);
1494         StringBuilder returnMsg = new StringBuilder();
1495         Uuid vpnId = input.getVpnId();
1496         Uuid routerId = input.getRouterId();
1497         try {
1498             if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1499                 if (routerId != null) {
1500                     Router rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
1501                     if (rtr != null) {
1502                         Uuid routerVpnId = NeutronvpnUtils.getVpnForRouter(broker, routerId, true);
1503                         if (vpnId.equals(routerVpnId)) {
1504                             dissociateRouterFromVpn(vpnId, routerId);
1505                         } else {
1506                             if (routerVpnId == null) {
1507                                 returnMsg.append("input router ").append(routerId.getValue()).append(" not associated" +
1508                                         " to any vpn yet");
1509                             } else {
1510                                 returnMsg.append("input router ").append(routerId.getValue()).append(" associated to " +
1511                                         "vpn ").append(routerVpnId.getValue()).append("instead of the vpn given as " +
1512                                         "input");
1513                             }
1514                         }
1515                     } else {
1516                         returnMsg.append("router not found : ").append(routerId.getValue());
1517                     }
1518                 }
1519             } else {
1520                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1521             }
1522             if (returnMsg.length() != 0) {
1523                 String message = String.format("dissociate router %s to vpn %s failed due to %s", routerId.getValue(),
1524                         vpnId.getValue(), returnMsg);
1525                 logger.error(message);
1526                 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1527                         message);
1528                 result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
1529                         .build());
1530             } else {
1531                 result.set(RpcResultBuilder.<Void>success().build());
1532             }
1533         } catch (Exception ex) {
1534             String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
1535                     vpnId.getValue(), ex.getMessage());
1536             logger.error(message, ex);
1537             result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
1538         }
1539         logger.debug("dissociateRouter returns..");
1540
1541         return result;
1542     }
1543
1544     @Override
1545     public Future<RpcResult<GetFixedIPsForNeutronPortOutput>> getFixedIPsForNeutronPort(GetFixedIPsForNeutronPortInput
1546                                                                                                 input) {
1547         GetFixedIPsForNeutronPortOutputBuilder opBuilder = new GetFixedIPsForNeutronPortOutputBuilder();
1548         SettableFuture<RpcResult<GetFixedIPsForNeutronPortOutput>> result = SettableFuture.create();
1549         Uuid portId = input.getPortId();
1550         StringBuilder returnMsg = new StringBuilder();
1551         try {
1552             List<String> fixedIPList = new ArrayList<>();
1553             Port port = NeutronvpnUtils.getNeutronPort(broker, portId);
1554             if (port != null) {
1555                 List<FixedIps> fixedIPs = port.getFixedIps();
1556                 for (FixedIps ip : fixedIPs) {
1557                     fixedIPList.add(ip.getIpAddress().getIpv4Address().getValue());
1558                 }
1559             } else {
1560                 returnMsg.append("neutron port: ").append(portId.getValue()).append(" not found");
1561             }
1562             if (returnMsg.length() != 0) {
1563                 String message = String.format("Retrieval of FixedIPList for neutron port failed due to %s", returnMsg);
1564                 logger.error(message);
1565                 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed().withWarning(ErrorType.PROTOCOL,
1566                         "invalid-value", message).build());
1567             } else {
1568                 opBuilder.setFixedIPs(fixedIPList);
1569                 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().withResult(opBuilder.build())
1570                         .build());
1571                 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().build());
1572             }
1573         } catch (Exception ex) {
1574             String message = String.format("Retrieval of FixedIPList for neutron port %s failed due to %s", portId
1575                     .getValue(), ex.getMessage());
1576             logger.error(message, ex);
1577             result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed().withError(ErrorType.APPLICATION,
1578                     message).build());
1579         }
1580         return result;
1581     }
1582
1583     protected void handleNeutronRouterDeleted(Uuid routerId, List<Uuid> routerSubnetIds) {
1584         // check if the router is associated to some VPN
1585         Uuid vpnId = NeutronvpnUtils.getVpnForRouter(broker, routerId, true);
1586         if (vpnId != null) {
1587             // remove existing external vpn interfaces
1588             for (Uuid subnetId : routerSubnetIds) {
1589                 removeSubnetFromVpn(vpnId, subnetId);
1590             }
1591             clearFromVpnMaps(vpnId, routerId, null);
1592         } else {
1593             // remove existing internal vpn interfaces
1594             for (Uuid subnetId : routerSubnetIds) {
1595                 removeSubnetFromVpn(routerId, subnetId);
1596             }
1597         }
1598         // delete entire vpnMaps node for internal VPN
1599         deleteVpnMapsNode(routerId);
1600
1601         // delete vpn-instance for internal VPN
1602         deleteVpnInstance(routerId);
1603     }
1604
1605     protected Subnet getNeutronSubnet(Uuid subnetId){
1606         return NeutronvpnUtils.getNeutronSubnet(broker, subnetId);
1607     }
1608
1609     protected IpAddress getNeutronSubnetGateway(Uuid subnetId) {
1610         Subnet sn = NeutronvpnUtils.getNeutronSubnet(broker, subnetId);
1611         if (null != sn) {
1612             return sn.getGatewayIp();
1613         }
1614         return null;
1615     }
1616
1617     protected Port getNeutronPort(String name) {
1618         return NeutronvpnUtils.getNeutronPort(broker, new Uuid(name));
1619     }
1620
1621     protected Port getNeutronPort(Uuid portId) {
1622         return NeutronvpnUtils.getNeutronPort(broker, portId);
1623     }
1624
1625     protected List<Uuid> getSubnetsforVpn(Uuid vpnid) {
1626         List<Uuid> subnets = new ArrayList<>();
1627         //read subnetmaps
1628         InstanceIdentifier<Subnetmaps> subnetmapsid = InstanceIdentifier.builder(Subnetmaps.class).build();
1629         Optional<Subnetmaps> subnetmaps = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
1630                 subnetmapsid);
1631         if (subnetmaps.isPresent() && subnetmaps.get().getSubnetmap() != null) {
1632             List<Subnetmap> subnetMapList = subnetmaps.get().getSubnetmap();
1633             for (Subnetmap subnetMap : subnetMapList) {
1634                 if (subnetMap.getVpnId() != null && subnetMap.getVpnId().equals(vpnid)) {
1635                     subnets.add(subnetMap.getId());
1636                 }
1637             }
1638         }
1639         return subnets;
1640     }
1641
1642     public List<String> showNeutronPortsCLI() {
1643         List<String> result = new ArrayList<>();
1644         result.add(String.format(" %-36s  %-19s  %-13s  %-20s ", "Port ID", "Mac Address", "Prefix Length", "IP " +
1645                 "Address"));
1646         result.add("-------------------------------------------------------------------------------------------");
1647         InstanceIdentifier<Ports> portidentifier = InstanceIdentifier.create(Neutron.class).child(Ports.class);
1648         try {
1649             Optional<Ports> ports = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, portidentifier);
1650             if (ports.isPresent() && ports.get().getPort() != null) {
1651                 for (Port port : ports.get().getPort()) {
1652                     List<FixedIps> fixedIPs = port.getFixedIps();
1653                     try {
1654                         if (fixedIPs != null && !fixedIPs.isEmpty()) {
1655                             List<String> ipList = new ArrayList<>();
1656                             for (FixedIps fixedIp : fixedIPs) {
1657                                 IpAddress ipAddress = fixedIp.getIpAddress();
1658                                 if (ipAddress.getIpv4Address() != null) {
1659                                     ipList.add(ipAddress.getIpv4Address().getValue());
1660                                 } else {
1661                                     ipList.add((ipAddress.getIpv6Address().getValue()));
1662                                 }
1663                             }
1664                             result.add(String.format(" %-36s  %-19s  %-13s  %-20s ", port.getUuid().getValue(), port
1665                                     .getMacAddress().getValue(), NeutronvpnUtils.getIPPrefixFromPort(broker, port),
1666                                     ipList.toString()));
1667                         } else {
1668                             result.add(String.format(" %-36s  %-19s  %-13s  %-20s ", port.getUuid().getValue(), port
1669                                     .getMacAddress().getValue(), "Not Assigned", "Not Assigned"));
1670                         }
1671                     } catch (Exception e) {
1672                         logger.error("Failed to retrieve neutronPorts info for port {}: ", port.getUuid().getValue(),
1673                                 e);
1674                         System.out.println("Failed to retrieve neutronPorts info for port: " + port.getUuid()
1675                                 .getValue() + ": " + e.getMessage());
1676                     }
1677                 }
1678             }
1679         } catch (Exception e) {
1680             logger.error("Failed to retrieve neutronPorts info : ", e);
1681             System.out.println("Failed to retrieve neutronPorts info : " + e.getMessage());
1682         }
1683         return result;
1684     }
1685
1686     public List<String> showVpnConfigCLI(Uuid vpnuuid) {
1687         List<String> result = new ArrayList<>();
1688         if (vpnuuid == null) {
1689             System.out.println("");
1690             System.out.println("Displaying VPN config for all VPNs");
1691             System.out.println("To display VPN config for a particular VPN, use the following syntax");
1692             System.out.println(getshowVpnConfigCLIHelp());
1693         }
1694         try {
1695             RpcResult<GetL3VPNOutput> rpcResult = getL3VPN(new GetL3VPNInputBuilder().setId(vpnuuid).build()).get();
1696             if (rpcResult.isSuccessful()) {
1697                 result.add("");
1698                 result.add(String.format(" %-37s %-37s %-7s ", "VPN ID", "Tenant ID", "RD"));
1699                 result.add("");
1700                 result.add(String.format(" %-80s ", "Import-RTs"));
1701                 result.add("");
1702                 result.add(String.format(" %-80s ", "Export-RTs"));
1703                 result.add("");
1704                 result.add(String.format(" %-76s ", "Subnet IDs"));
1705                 result.add("");
1706                 result.add("------------------------------------------------------------------------------------");
1707                 result.add("");
1708                 List<L3vpnInstances> VpnList = rpcResult.getResult().getL3vpnInstances();
1709                 for (L3vpnInstance Vpn : VpnList) {
1710                     String tenantId = Vpn.getTenantId() != null ? Vpn.getTenantId().getValue() : "\"                 " +
1711                             "                  \"";
1712                     result.add(String.format(" %-37s %-37s %-7s ", Vpn.getId().getValue(), tenantId, Vpn
1713                             .getRouteDistinguisher()));
1714                     result.add("");
1715                     result.add(String.format(" %-80s ", Vpn.getImportRT()));
1716                     result.add("");
1717                     result.add(String.format(" %-80s ", Vpn.getExportRT()));
1718                     result.add("");
1719
1720                     Uuid vpnid = Vpn.getId();
1721                     List<Uuid> subnetList = getSubnetsforVpn(vpnid);
1722                     if (!subnetList.isEmpty()) {
1723                         for (Uuid subnetuuid : subnetList) {
1724                             result.add(String.format(" %-76s ", subnetuuid.getValue()));
1725                         }
1726                     } else {
1727                         result.add(String.format(" %-76s ", "\"                                    \""));
1728                     }
1729                     result.add("");
1730                     result.add("----------------------------------------");
1731                     result.add("");
1732                 }
1733             } else {
1734                 String errortag = rpcResult.getErrors().iterator().next().getTag();
1735                 if (errortag == "") {
1736                     System.out.println("");
1737                     System.out.println("No VPN has been configured yet");
1738                 } else if (errortag == "invalid-value") {
1739                     System.out.println("");
1740                     System.out.println("VPN " + vpnuuid.getValue() + " is not present");
1741                 } else {
1742                     System.out.println("error getting VPN info : " + rpcResult.getErrors());
1743                     System.out.println(getshowVpnConfigCLIHelp());
1744                 }
1745             }
1746         } catch (InterruptedException | ExecutionException e) {
1747             logger.error("error getting VPN info : ", e);
1748             System.out.println("error getting VPN info : " + e.getMessage());
1749         }
1750         return result;
1751     }
1752
1753     private String getshowVpnConfigCLIHelp() {
1754         StringBuilder help = new StringBuilder("Usage:");
1755         help.append("display vpn-config [-vid/--vpnid <id>]");
1756         return help.toString();
1757     }
1758
1759     private void checkAndPublishSubnetAddNotification(Uuid subnetId, String subnetIp, String vpnName,
1760                                                       Boolean isExternalvpn, Long elanTag)throws InterruptedException {
1761         SubnetAddedToVpnBuilder builder = new SubnetAddedToVpnBuilder();
1762
1763         logger.info("publish notification called");
1764
1765         builder.setSubnetId(subnetId);
1766         builder.setSubnetIp(subnetIp);
1767         builder.setVpnName(vpnName);
1768         builder.setExternalVpn(isExternalvpn);
1769         builder.setElanTag(elanTag);
1770
1771         notificationPublishService.putNotification(builder.build());
1772     }
1773
1774     private void checkAndPublishSubnetDelNotification(Uuid subnetId, String subnetIp, String vpnName,
1775                                                       Boolean isExternalvpn, Long elanTag) throws InterruptedException {
1776         SubnetDeletedFromVpnBuilder builder = new SubnetDeletedFromVpnBuilder();
1777
1778         logger.info("publish notification called");
1779
1780         builder.setSubnetId(subnetId);
1781         builder.setSubnetIp(subnetIp);
1782         builder.setVpnName(vpnName);
1783         builder.setExternalVpn(isExternalvpn);
1784         builder.setElanTag(elanTag);
1785
1786         notificationPublishService.putNotification(builder.build());
1787     }
1788
1789     private void checkAndPublishSubnetUpdNotification(Uuid subnetId, String subnetIp, String vpnName,
1790                                                       Boolean isExternalvpn, Long elanTag) throws InterruptedException {
1791         SubnetUpdatedInVpnBuilder builder = new SubnetUpdatedInVpnBuilder();
1792
1793         logger.info("publish notification called");
1794
1795         builder.setSubnetId(subnetId);
1796         builder.setSubnetIp(subnetIp);
1797         builder.setVpnName(vpnName);
1798         builder.setExternalVpn(isExternalvpn);
1799         builder.setElanTag(elanTag);
1800
1801         notificationPublishService.putNotification(builder.build());
1802     }
1803
1804     private void checkAndPublishRouterAssociatedtoVpnNotification(Uuid routerId, Uuid vpnId) throws
1805             InterruptedException {
1806         RouterAssociatedToVpn routerAssociatedToVpn = new RouterAssociatedToVpnBuilder().setRouterId(routerId)
1807                 .setVpnId(vpnId).build();
1808         logger.info("publishing notification upon association of router to VPN");
1809         notificationPublishService.putNotification(routerAssociatedToVpn);
1810     }
1811
1812     private void checkAndPublishRouterDisassociatedFromVpnNotification(Uuid routerId, Uuid vpnId) throws
1813             InterruptedException {
1814         RouterDisassociatedFromVpn routerDisassociatedFromVpn = new RouterDisassociatedFromVpnBuilder().setRouterId
1815                 (routerId).setVpnId(vpnId).build();
1816         logger.info("publishing notification upon disassociation of router from VPN");
1817         notificationPublishService.putNotification(routerDisassociatedFromVpn);
1818     }
1819 }