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

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.vpnservice.neutronvpn;
   9
  10 import com.google.common.base.Optional;
  11 import com.google.common.util.concurrent.SettableFuture;
  12 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  13 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  14 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  15 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  16 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  17 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  18 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargets;
  19 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargetsBuilder;
  20 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget;
  21 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets
  22         .VpnTargetBuilder;
  23 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTargetKey;
  24 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  25 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceBuilder;
  26 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  27 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.vpn.instance
  28         .Ipv4FamilyBuilder;
  29 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  30 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.Adjacencies;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.AdjacenciesBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.Adjacency;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.l3vpn.rev130911.adjacency.list.AdjacencyKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.l3.attributes.Routes;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.lockmanager.rev150819.LockManagerService;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateNetworksInput;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateNetworksOutput;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateNetworksOutputBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.AssociateRouterInput;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.CreateL3VPNInput;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.CreateL3VPNOutput;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.CreateL3VPNOutputBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DeleteL3VPNInput;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DeleteL3VPNOutput;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DeleteL3VPNOutputBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateNetworksInput;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateNetworksOutput;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateNetworksOutputBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.DissociateRouterInput;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetFixedIPsForNeutronPortInput;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetFixedIPsForNeutronPortOutput;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602
  67         .GetFixedIPsForNeutronPortOutputBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNInput;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNInputBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNOutput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.GetL3VPNOutputBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.L3vpnInstance;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.NeutronvpnService;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.Subnetmaps;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.VpnMaps;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.createl3vpn.input.L3vpn;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.getl3vpn.output.L3vpnInstances;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.getl3vpn.output
  79         .L3vpnInstancesBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.Subnetmap;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.SubnetmapBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMap;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMapBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.vpnservice.neutronvpn.rev150602.vpnmaps.VpnMapKey;
  86 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  87 import org.opendaylight.yangtools.yang.common.RpcError;
  88 import org.opendaylight.yangtools.yang.common.RpcError.ErrorType;
  89 import org.opendaylight.yangtools.yang.common.RpcResult;
  90 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  91 import org.slf4j.Logger;
  92 import org.slf4j.LoggerFactory;
  93 import java.util.ArrayList;
  94 import java.util.Arrays;
  95 import java.util.List;
  96 import java.util.concurrent.ExecutionException;
  97 import java.util.concurrent.Future;
  98
  99 public class NeutronvpnManager implements NeutronvpnService, AutoCloseable {
 100
 101     private static final Logger logger = LoggerFactory.getLogger(NeutronvpnManager.class);
 102     private final DataBroker broker;
 103     private LockManagerService lockManager;
 104     IMdsalApiManager mdsalUtil;
 105
 106     /**
 107      * @param db           - dataBroker reference
 108      * @param mdsalManager - MDSAL Util API access
 109      */
 110     public NeutronvpnManager(final DataBroker db, IMdsalApiManager mdsalManager) {
 111         broker = db;
 112         mdsalUtil = mdsalManager;
 113     }
 114
 115     public void setLockManager(LockManagerService lockManager) {
 116         this.lockManager = lockManager;
 117     }
 118
 119     @Override
 120     public void close() throws Exception {
 121         logger.info("Neutron VPN Manager Closed");
 122     }
 123
 124     protected Subnetmap updateSubnetNode(Uuid subnetId, String subnetIp, Uuid tenantId, Uuid networkId, Uuid routerId,
 125                                          Uuid vpnId, Uuid portId) {
 126         Subnetmap subnetmap = null;
 127         SubnetmapBuilder builder = null;
 128         boolean isLockAcquired = false;
 129         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
 130                 child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
 131         try {
 132             Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 133             logger.debug("updating Subnet :read: ");
 134             if (sn.isPresent()) {
 135                 builder = new SubnetmapBuilder(sn.get());
 136                 logger.debug("updating Subnet :existing: ");
 137             } else {
 138                 builder = new SubnetmapBuilder().setKey(new SubnetmapKey(subnetId)).setId(subnetId);
 139                 logger.debug("updating Subnet :new: ");
 140             }
 141
 142             if (subnetIp != null) {
 143                 builder.setSubnetIp(subnetIp);
 144             }
 145             if (routerId != null) {
 146                 builder.setRouterId(routerId);
 147             }
 148             if (networkId != null) {
 149                 builder.setNetworkId(networkId);
 150             }
 151             if (vpnId != null) {
 152                 builder.setVpnId(vpnId);
 153             }
 154             if (tenantId != null) {
 155                 builder.setTenantId(tenantId);
 156             }
 157
 158             if (portId != null) {
 159                 List<Uuid> portList = builder.getPortList();
 160                 if (portList == null) {
 161                     portList = new ArrayList<Uuid>();
 162                 }
 163                 portList.add(portId);
 164                 builder.setPortList(portList);
 165             }
 166
 167             subnetmap = builder.build();
 168             isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 169             logger.debug("Creating/Updating subnetMap node: {} ", subnetId.getValue());
 170             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
 171         } catch (Exception e) {
 172             logger.error("Updation of subnetMap failed for node: {}", subnetId.getValue());
 173         } finally {
 174             if (isLockAcquired) {
 175                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 176             }
 177         }
 178         return subnetmap;
 179     }
 180
 181     protected Subnetmap removeFromSubnetNode(Uuid subnetId, Uuid networkId, Uuid routerId, Uuid vpnId, Uuid portId) {
 182         Subnetmap subnetmap = null;
 183         boolean isLockAcquired = false;
 184         InstanceIdentifier<Subnetmap> id = InstanceIdentifier.builder(Subnetmaps.class).
 185                 child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
 186         try {
 187             Optional<Subnetmap> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 188             if (sn.isPresent()) {
 189                 SubnetmapBuilder builder = new SubnetmapBuilder(sn.get());
 190                 if (routerId != null) {
 191                     builder.setRouterId(null);
 192                 }
 193                 if (networkId != null) {
 194                     builder.setNetworkId(null);
 195                 }
 196                 if (vpnId != null) {
 197                     builder.setVpnId(null);
 198                 }
 199                 if (portId != null && builder.getPortList() != null) {
 200                     List<Uuid> portList = builder.getPortList();
 201                     portList.remove(portId);
 202                     builder.setPortList(portList);
 203                 }
 204
 205                 subnetmap = builder.build();
 206                 isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 207                 logger.debug("Removing from existing subnetmap node: {} ", subnetId.getValue());
 208                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, id, subnetmap);
 209             } else {
 210                 logger.warn("removing from non-existing subnetmap node: {} ", subnetId.getValue());
 211             }
 212         } catch (Exception e) {
 213             logger.error("Removal from subnetmap failed for node: {}", subnetId.getValue());
 214         } finally {
 215             if (isLockAcquired) {
 216                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 217             }
 218         }
 219         return subnetmap;
 220     }
 221
 222     protected void deleteSubnetMapNode(Uuid subnetId) {
 223         boolean isLockAcquired = false;
 224         InstanceIdentifier<Subnetmap> subnetMapIdentifier = InstanceIdentifier.builder(Subnetmaps.class)
 225                 .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
 226         logger.debug("removing subnetMap node: {} ", subnetId.getValue());
 227         try {
 228             isLockAcquired = NeutronvpnUtils.lock(lockManager, subnetId.getValue());
 229             MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, subnetMapIdentifier);
 230         } catch (Exception e) {
 231             logger.error("Delete subnetMap node failed for subnet : {} ", subnetId.getValue());
 232         } finally {
 233             if (isLockAcquired) {
 234                 NeutronvpnUtils.unlock(lockManager, subnetId.getValue());
 235             }
 236         }
 237     }
 238
 239     private void updateVpnInstanceNode(String vpnName, List<String> rd, List<String> irt, List<String> ert) {
 240
 241         VpnInstanceBuilder builder = null;
 242         List<VpnTarget> vpnTargetList = new ArrayList<VpnTarget>();
 243         boolean isLockAcquired = false;
 244         InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
 245                 child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 246         try {
 247             Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 248                     vpnIdentifier);
 249             logger.debug("Creating/Updating a new vpn-instance node: {} ", vpnName);
 250             if (optionalVpn.isPresent()) {
 251                 builder = new VpnInstanceBuilder(optionalVpn.get());
 252                 logger.debug("updating existing vpninstance node");
 253             } else {
 254                 builder = new VpnInstanceBuilder().setKey(new VpnInstanceKey(vpnName)).setVpnInstanceName(vpnName);
 255             }
 256             if (irt != null && !irt.isEmpty()) {
 257                 if (ert != null && !ert.isEmpty()) {
 258                     List<String> commonRT = new ArrayList<String>(irt);
 259                     commonRT.retainAll(ert);
 260
 261                     for (String common : commonRT) {
 262                         irt.remove(common);
 263                         ert.remove(common);
 264                         VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(common)).setVrfRTValue
 265                                 (common).setVrfRTType(VpnTarget.VrfRTType.Both).build();
 266                         vpnTargetList.add(vpnTarget);
 267                     }
 268                 }
 269                 for (String importRT : irt) {
 270                     VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(importRT)).setVrfRTValue
 271                             (importRT).setVrfRTType(VpnTarget.VrfRTType.ImportExtcommunity).build();
 272                     vpnTargetList.add(vpnTarget);
 273                 }
 274             }
 275
 276             if (ert != null && !ert.isEmpty()) {
 277                 for (String exportRT : ert) {
 278                     VpnTarget vpnTarget = new VpnTargetBuilder().setKey(new VpnTargetKey(exportRT)).setVrfRTValue
 279                             (exportRT).setVrfRTType(VpnTarget.VrfRTType.ExportExtcommunity).build();
 280                     vpnTargetList.add(vpnTarget);
 281                 }
 282             }
 283
 284             VpnTargets vpnTargets = new VpnTargetsBuilder().setVpnTarget(vpnTargetList).build();
 285
 286             Ipv4FamilyBuilder ipv4vpnBuilder = new Ipv4FamilyBuilder().setVpnTargets(vpnTargets);
 287
 288             if (rd != null && !rd.isEmpty()) {
 289                 ipv4vpnBuilder.setRouteDistinguisher(rd.get(0));
 290             }
 291
 292             VpnInstance newVpn = builder.setIpv4Family(ipv4vpnBuilder.build()).build();
 293             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnName);
 294             logger.debug("Creating/Updating vpn-instance for {} ", vpnName);
 295             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier, newVpn);
 296         } catch (Exception e) {
 297             logger.error("Update VPN Instance node failed for node: {} {} {} {}", vpnName, rd, irt, ert);
 298         } finally {
 299             if (isLockAcquired) {
 300                 NeutronvpnUtils.unlock(lockManager, vpnName);
 301             }
 302         }
 303     }
 304
 305     private void deleteVpnMapsNode(Uuid vpnid) {
 306         boolean isLockAcquired = false;
 307         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 308                 .child(VpnMap.class, new VpnMapKey(vpnid)).build();
 309         logger.debug("removing vpnMaps node: {} ", vpnid.getValue());
 310         try {
 311             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnid.getValue());
 312             MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
 313         } catch (Exception e) {
 314             logger.error("Delete vpnMaps node failed for vpn : {} ", vpnid.getValue());
 315         } finally {
 316             if (isLockAcquired) {
 317                 NeutronvpnUtils.unlock(lockManager, vpnid.getValue());
 318             }
 319         }
 320     }
 321
 322     private void updateVpnMaps(Uuid vpnId, String name, Uuid router, Uuid tenantId, List<Uuid> networks) {
 323         VpnMapBuilder builder;
 324         boolean isLockAcquired = false;
 325         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 326                 .child(VpnMap.class, new VpnMapKey(vpnId)).build();
 327         try {
 328             Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 329                     vpnMapIdentifier);
 330             if (optionalVpnMap.isPresent()) {
 331                 builder = new VpnMapBuilder(optionalVpnMap.get());
 332             } else {
 333                 builder = new VpnMapBuilder().setKey(new VpnMapKey(vpnId)).setVpnId(vpnId);
 334             }
 335
 336             if (name != null) {
 337                 builder.setName(name);
 338             }
 339             if (tenantId != null) {
 340                 builder.setTenantId(tenantId);
 341             }
 342             if (router != null) {
 343                 builder.setRouterId(router);
 344             }
 345             if (networks != null) {
 346                 List<Uuid> nwList = builder.getNetworkIds();
 347                 if (nwList == null) {
 348                     nwList = new ArrayList<Uuid>();
 349                 }
 350                 nwList.addAll(networks);
 351                 builder.setNetworkIds(nwList);
 352             }
 353
 354             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 355             logger.debug("Creating/Updating vpnMaps node: {} ", vpnId.getValue());
 356             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, builder.build());
 357             logger.debug("VPNMaps DS updated for VPN {} ", vpnId.getValue());
 358         } catch (Exception e) {
 359             logger.error("UpdateVpnMaps failed for node: {} ", vpnId.getValue());
 360         } finally {
 361             if (isLockAcquired) {
 362                 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 363             }
 364         }
 365     }
 366
 367     private void clearFromVpnMaps(Uuid vpnId, Uuid routerId, List<Uuid> networkIds) {
 368         boolean isLockAcquired = false;
 369         InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class)
 370                 .child(VpnMap.class, new VpnMapKey(vpnId)).build();
 371         Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 372                 vpnMapIdentifier);
 373         if (optionalVpnMap.isPresent()) {
 374             VpnMap vpnMap = optionalVpnMap.get();
 375             VpnMapBuilder vpnMapBuilder = new VpnMapBuilder(vpnMap);
 376             if (routerId != null) {
 377                 if (vpnMap.getNetworkIds() == null && routerId.equals(vpnMap.getVpnId())) {
 378                     try {
 379                         // remove entire node in case of internal VPN
 380                         isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 381                         logger.debug("removing vpnMaps node: {} ", vpnId);
 382                         MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier);
 383                     } catch (Exception e) {
 384                         logger.error("Deletion of vpnMaps node failed for vpn {}", vpnId.getValue());
 385                     } finally {
 386                         if (isLockAcquired) {
 387                             NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 388                         }
 389                     }
 390                     return;
 391                 }
 392                 vpnMapBuilder.setRouterId(null);
 393             }
 394             if (networkIds != null) {
 395                 List<Uuid> vpnNw = vpnMap.getNetworkIds();
 396                 for (Uuid nw : networkIds) {
 397                     vpnNw.remove(nw);
 398                 }
 399                 if (vpnNw.isEmpty()) {
 400                     logger.debug("setting networks null in vpnMaps node: {} ", vpnId.getValue());
 401                     vpnMapBuilder.setNetworkIds(null);
 402                 } else {
 403                     vpnMapBuilder.setNetworkIds(vpnNw);
 404                 }
 405             }
 406
 407             try {
 408                 isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 409                 logger.debug("clearing from vpnMaps node: {} ", vpnId.getValue());
 410                 MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnMapIdentifier, vpnMapBuilder.build
 411                         ());
 412             } catch (Exception e) {
 413                 logger.error("Clearing from vpnMaps node failed for vpn {}", vpnId.getValue());
 414             } finally {
 415                 if (isLockAcquired) {
 416                     NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 417                 }
 418             }
 419         } else {
 420             logger.error("VPN : {} not found", vpnId.getValue());
 421         }
 422         logger.debug("Clear from VPNMaps DS successful for VPN {} ", vpnId.getValue());
 423     }
 424
 425     private void deleteVpnInstance(Uuid vpnId) {
 426         boolean isLockAcquired = false;
 427         InstanceIdentifier<VpnInstance> vpnIdentifier = InstanceIdentifier.builder(VpnInstances.class).
 428                 child(VpnInstance.class, new VpnInstanceKey(vpnId.getValue())).build();
 429         try {
 430             isLockAcquired = NeutronvpnUtils.lock(lockManager, vpnId.getValue());
 431             logger.debug("Deleting vpnInstance {}", vpnId.getValue());
 432             MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIdentifier);
 433         } catch (Exception e) {
 434             logger.error("Deletion of VPNInstance node failed for VPN {}", vpnId.getValue());
 435         } finally {
 436             if (isLockAcquired) {
 437                 NeutronvpnUtils.unlock(lockManager, vpnId.getValue());
 438             }
 439         }
 440     }
 441
 442     protected void createVpnInterface(Uuid vpnId, Port port) {
 443         boolean isLockAcquired = false;
 444         if (vpnId == null || port == null) {
 445             return;
 446         }
 447         String infName = port.getUuid().getValue();
 448         List<Adjacency> adjList = new ArrayList<Adjacency>();
 449         InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
 450
 451         // find router associated to vpn
 452         Uuid routerId = NeutronvpnUtils.getRouterforVpn(broker, vpnId);
 453         Router rtr = null;
 454         if (routerId != null) {
 455             rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
 456         }
 457         // find all subnets to which this port is associated
 458         List<FixedIps> ips = port.getFixedIps();
 459         // create adjacency list
 460         for (FixedIps ip : ips) {
 461             // create vm adjacency
 462             StringBuilder IpPrefixBuild = new StringBuilder(ip.getIpAddress().getIpv4Address().getValue());
 463             String IpPrefix = IpPrefixBuild.append("/32").toString();
 464             Adjacency vmAdj = new AdjacencyBuilder().setKey(new AdjacencyKey(IpPrefix)).setIpAddress(IpPrefix)
 465                     .setMacAddress(port.getMacAddress()).build();
 466             adjList.add(vmAdj);
 467             // create extra route adjacency
 468             if (rtr != null && rtr.getRoutes() != null) {
 469                 List<Routes> routeList = rtr.getRoutes();
 470                 List<Adjacency> erAdjList = addAdjacencyforExtraRoute(routeList, false, infName);
 471                 if (erAdjList != null && !erAdjList.isEmpty()) {
 472                     adjList.addAll(erAdjList);
 473                 }
 474             }
 475         }
 476         // create vpn-interface on this neutron port
 477         Adjacencies adjs = new AdjacenciesBuilder().setAdjacency(adjList).build();
 478         VpnInterfaceBuilder vpnb = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName)).
 479                 setName(infName).setVpnInstanceName(vpnId.getValue()).addAugmentation(Adjacencies.class, adjs);
 480         VpnInterface vpnIf = vpnb.build();
 481
 482         try {
 483             isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 484             logger.debug("Creating vpn interface {}", vpnIf);
 485             MDSALUtil.syncWrite(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
 486         } catch (Exception ex) {
 487             logger.error("Creation of vpninterface {} failed due to {}", infName, ex);
 488         } finally {
 489             if (isLockAcquired) {
 490                 NeutronvpnUtils.unlock(lockManager, infName);
 491             }
 492         }
 493     }
 494
 495     protected void deleteVpnInterface(Port port) {
 496
 497         if (port != null) {
 498             boolean isLockAcquired = false;
 499             String infName = port.getUuid().getValue();
 500             InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
 501
 502             try {
 503                 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 504                 logger.debug("Deleting vpn interface {}", infName);
 505                 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier);
 506             } catch (Exception ex) {
 507                 logger.error("Deletion of vpninterface {} failed due to {}", infName, ex);
 508             } finally {
 509                 if (isLockAcquired) {
 510                     NeutronvpnUtils.unlock(lockManager, infName);
 511                 }
 512             }
 513         }
 514     }
 515
 516     protected void updateVpnInterface(Uuid vpnId, Port port) {
 517         if (vpnId == null || port == null) {
 518             return;
 519         }
 520         boolean isLockAcquired = false;
 521         String infName = port.getUuid().getValue();
 522         InstanceIdentifier<VpnInterface> vpnIfIdentifier = NeutronvpnUtils.buildVpnInterfaceIdentifier(infName);
 523         try {
 524             Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
 525                     .CONFIGURATION, vpnIfIdentifier);
 526             if (optionalVpnInterface.isPresent()) {
 527                 VpnInterfaceBuilder vpnIfBuilder = new VpnInterfaceBuilder(optionalVpnInterface.get());
 528                 VpnInterface vpnIf = vpnIfBuilder.setVpnInstanceName(vpnId.getValue()).build();
 529                 isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 530                 logger.debug("Updating vpn interface {}", vpnIf);
 531                 MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
 532             } else {
 533                 logger.error("VPN Interface {} not found", infName);
 534             }
 535         } catch (Exception ex) {
 536             logger.error("Updation of vpninterface {} failed due to {}", infName, ex);
 537         } finally {
 538             if (isLockAcquired) {
 539                 NeutronvpnUtils.unlock(lockManager, infName);
 540             }
 541         }
 542     }
 543
 544     public void createL3Vpn(Uuid vpn, String name, Uuid tenant, List<String> rd, List<String> irt, List<String> ert,
 545                             Uuid router, List<Uuid> networks) {
 546
 547         // Update VPN Instance node
 548         updateVpnInstanceNode(vpn.getValue(), rd, irt, ert);
 549
 550         // Update local vpn-subnet DS
 551         updateVpnMaps(vpn, name, router, tenant, networks);
 552
 553         if (router != null) {
 554             associateRouterToVpn(vpn, router);
 555         }
 556         if (networks != null) {
 557             associateNetworksToVpn(vpn, networks);
 558         }
 559     }
 560
 561     @Override
 562     public Future<RpcResult<CreateL3VPNOutput>> createL3VPN(CreateL3VPNInput input) {
 563
 564         CreateL3VPNOutputBuilder opBuilder = new CreateL3VPNOutputBuilder();
 565         SettableFuture<RpcResult<CreateL3VPNOutput>> result = SettableFuture.create();
 566         List<RpcError> errorList = new ArrayList<RpcError>();
 567         int failurecount = 0;
 568         int warningcount = 0;
 569
 570         List<L3vpn> vpns = input.getL3vpn();
 571         for (L3vpn vpn : vpns) {
 572             RpcError error = null;
 573             String msg;
 574             if (vpn.getRouteDistinguisher() == null || vpn.getImportRT() == null || vpn.getExportRT() == null) {
 575                 msg = String.format("Creation of L3VPN failed for VPN %s due to absence of RD/iRT/eRT input",
 576                         vpn.getId().getValue());
 577                 logger.warn(msg);
 578                 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 579                 errorList.add(error);
 580                 warningcount++;
 581                 continue;
 582             }
 583             if (vpn.getRouteDistinguisher().size() > 1) {
 584                 msg = String.format("Creation of L3VPN failed for VPN %s due to multiple RD input %s",
 585                         vpn.getId().getValue(), vpn.getRouteDistinguisher());
 586                 logger.warn(msg);
 587                 error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 588                 errorList.add(error);
 589                 warningcount++;
 590                 continue;
 591             }
 592             if (vpn.getRouterId() != null) {
 593                 if (NeutronvpnUtils.getNeutronRouter(broker, vpn.getRouterId()) == null) {
 594                     msg = String.format("Creation of L3VPN failed for VPN %s due to router not found %s",
 595                             vpn.getId().getValue(), vpn.getRouterId().getValue());
 596                     logger.warn(msg);
 597                     error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 598                     errorList.add(error);
 599                     warningcount++;
 600                     continue;
 601                 }
 602                 Uuid vpnId = NeutronvpnUtils.getVpnForRouter(broker, vpn.getRouterId(), true);
 603                 if (vpnId != null) {
 604                     msg = String.format("Creation of L3VPN failed for VPN %s due to router %s already associated to " +
 605                             "another VPN %s", vpn.getId().getValue(), vpn.getRouterId().getValue(), vpnId.getValue());
 606                     logger.warn(msg);
 607                     error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 608                     errorList.add(error);
 609                     warningcount++;
 610                     continue;
 611                 }
 612             }
 613             if (vpn.getNetworkIds() != null) {
 614                 for (Uuid nw : vpn.getNetworkIds()) {
 615                     Network network = NeutronvpnUtils.getNeutronNetwork(broker, nw);
 616                     Uuid vpnId = NeutronvpnUtils.getVpnForNetwork(broker, nw);
 617                     if (network == null) {
 618                         msg = String.format("Creation of L3VPN failed for VPN %s due to network not found %s",
 619                                 vpn.getId().getValue(), nw.getValue());
 620                         logger.warn(msg);
 621                         error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 622                         errorList.add(error);
 623                         warningcount++;
 624                     } else if (vpnId != null) {
 625                         msg = String.format("Creation of L3VPN failed for VPN %s due to network %s already associated" +
 626                                 " to another VPN %s", vpn.getId().getValue(), nw.getValue(), vpnId.getValue());
 627                         logger.warn(msg);
 628                         error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-input", msg);
 629                         errorList.add(error);
 630                         warningcount++;
 631                     }
 632                 }
 633                 if (error != null) {
 634                     continue;
 635                 }
 636             }
 637             try {
 638                 createL3Vpn(vpn.getId(), vpn.getName(), vpn.getTenantId(), vpn.getRouteDistinguisher(),
 639                         vpn.getImportRT(), vpn.getExportRT(), vpn.getRouterId(), vpn.getNetworkIds());
 640             } catch (Exception ex) {
 641                 msg = String.format("Creation of L3VPN failed for VPN %s", vpn.getId().getValue());
 642                 logger.error(msg, ex);
 643                 error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
 644                 errorList.add(error);
 645                 failurecount++;
 646             }
 647         }
 648         // if at least one succeeds; result is success
 649         // if none succeeds; result is failure
 650         if (failurecount + warningcount == vpns.size()) {
 651             result.set(RpcResultBuilder.<CreateL3VPNOutput>failed().withRpcErrors(errorList).build());
 652         } else {
 653             List<String> errorResponseList = new ArrayList<>();
 654             if (!errorList.isEmpty()) {
 655                 for (RpcError rpcError : errorList) {
 656                     String errorResponse = String.format("ErrorType: " + rpcError.getErrorType() + ", " + "ErrorTag: " +
 657                             rpcError.getTag() + ", " + "ErrorMessage: " + rpcError.getMessage());
 658                     errorResponseList.add(errorResponse);
 659                 }
 660             } else {
 661                 errorResponseList.add("Operation successful with no errors");
 662             }
 663             opBuilder.setResponse(errorResponseList);
 664             result.set(RpcResultBuilder.<CreateL3VPNOutput>success().withResult(opBuilder.build()).build());
 665         }
 666         return result;
 667     }
 668
 669     @Override
 670     public Future<RpcResult<GetL3VPNOutput>> getL3VPN(GetL3VPNInput input) {
 671
 672         GetL3VPNOutputBuilder opBuilder = new GetL3VPNOutputBuilder();
 673         SettableFuture<RpcResult<GetL3VPNOutput>> result = SettableFuture.create();
 674         Uuid inputVpnId = input.getId();
 675         List<VpnInstance> vpns = new ArrayList<VpnInstance>();
 676
 677         try {
 678             if (inputVpnId == null) {
 679                 // get all vpns
 680                 InstanceIdentifier<VpnInstances> vpnsIdentifier =
 681                         InstanceIdentifier.builder(VpnInstances.class).build();
 682                 Optional<VpnInstances> optionalVpns = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 683                         vpnsIdentifier);
 684                 if (optionalVpns.isPresent() && optionalVpns.get().getVpnInstance() != null) {
 685                     for (VpnInstance vpn : optionalVpns.get().getVpnInstance()) {
 686                         // eliminating internal VPNs from getL3VPN output
 687                         if (vpn.getIpv4Family().getRouteDistinguisher() != null) {
 688                             vpns.add(vpn);
 689                         }
 690                     }
 691                 } else {
 692                     // No VPN present
 693                     result.set(RpcResultBuilder.<GetL3VPNOutput>failed()
 694                             .withWarning(ErrorType.PROTOCOL, "", "No VPN is present").build());
 695                     return result;
 696                 }
 697             } else {
 698                 String name = inputVpnId.getValue();
 699                 InstanceIdentifier<VpnInstance> vpnIdentifier =
 700                         InstanceIdentifier.builder(VpnInstances.class)
 701                                 .child(VpnInstance.class, new VpnInstanceKey(name)).build();
 702                 // read VpnInstance Info
 703                 Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 704                         vpnIdentifier);
 705                 if (optionalVpn.isPresent()) {
 706                     vpns.add(optionalVpn.get());
 707                 } else {
 708                     String message = String.format("GetL3VPN failed because VPN %s is not present", name);
 709                     logger.error(message);
 710                     result.set(RpcResultBuilder.<GetL3VPNOutput>failed()
 711                             .withWarning(ErrorType.PROTOCOL, "invalid-value", message).build());
 712                 }
 713             }
 714             List<L3vpnInstances> l3vpnList = new ArrayList<L3vpnInstances>();
 715             for (VpnInstance vpnInstance : vpns) {
 716                 Uuid vpnId = new Uuid(vpnInstance.getVpnInstanceName());
 717                 // create VpnMaps id
 718                 InstanceIdentifier<VpnMap> vpnMapIdentifier = InstanceIdentifier.builder(VpnMaps.class).child(VpnMap
 719                         .class, new VpnMapKey(vpnId)).build();
 720                 L3vpnInstancesBuilder l3vpn = new L3vpnInstancesBuilder();
 721
 722                 List<String> rd = Arrays.asList(vpnInstance.getIpv4Family().getRouteDistinguisher().split(","));
 723                 List<VpnTarget> vpnTargetList = vpnInstance.getIpv4Family().getVpnTargets().getVpnTarget();
 724
 725                 List<String> ertList = new ArrayList<String>();
 726                 List<String> irtList = new ArrayList<String>();
 727
 728                 for (VpnTarget vpnTarget : vpnTargetList) {
 729                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ExportExtcommunity) {
 730                         ertList.add(vpnTarget.getVrfRTValue());
 731                     }
 732                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.ImportExtcommunity) {
 733                         irtList.add(vpnTarget.getVrfRTValue());
 734                     }
 735                     if (vpnTarget.getVrfRTType() == VpnTarget.VrfRTType.Both) {
 736                         ertList.add(vpnTarget.getVrfRTValue());
 737                         irtList.add(vpnTarget.getVrfRTValue());
 738                     }
 739                 }
 740
 741                 l3vpn.setId(vpnId).setRouteDistinguisher(rd).setImportRT(irtList).setExportRT(ertList);
 742                 Optional<VpnMap> optionalVpnMap = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 743                         vpnMapIdentifier);
 744                 if (optionalVpnMap.isPresent()) {
 745                     VpnMap vpnMap = optionalVpnMap.get();
 746                     l3vpn.setRouterId(vpnMap.getRouterId()).setNetworkIds(vpnMap.getNetworkIds())
 747                             .setTenantId(vpnMap.getTenantId()).setName(vpnMap.getName());
 748                 }
 749                 l3vpnList.add(l3vpn.build());
 750             }
 751
 752             opBuilder.setL3vpnInstances(l3vpnList);
 753             result.set(RpcResultBuilder.<GetL3VPNOutput>success().withResult(opBuilder.build()).build());
 754
 755         } catch (Exception ex) {
 756             String message = String.format("GetL3VPN failed due to %s", ex.getMessage());
 757             logger.error(message, ex);
 758             result.set(RpcResultBuilder.<GetL3VPNOutput>failed().withError(ErrorType.APPLICATION, message).build());
 759         }
 760         return result;
 761     }
 762
 763     @Override
 764     public Future<RpcResult<DeleteL3VPNOutput>> deleteL3VPN(DeleteL3VPNInput input) {
 765
 766         DeleteL3VPNOutputBuilder opBuilder = new DeleteL3VPNOutputBuilder();
 767         SettableFuture<RpcResult<DeleteL3VPNOutput>> result = SettableFuture.create();
 768         List<RpcError> errorList = new ArrayList<RpcError>();
 769
 770         int failurecount = 0;
 771         int warningcount = 0;
 772         List<Uuid> vpns = input.getId();
 773         for (Uuid vpn : vpns) {
 774             RpcError error;
 775             String msg;
 776             try {
 777                 InstanceIdentifier<VpnInstance> vpnIdentifier =
 778                         InstanceIdentifier.builder(VpnInstances.class)
 779                                 .child(VpnInstance.class, new VpnInstanceKey(vpn.getValue())).build();
 780                 Optional<VpnInstance> optionalVpn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
 781                         vpnIdentifier);
 782                 if (optionalVpn.isPresent()) {
 783                     removeL3Vpn(vpn);
 784                 } else {
 785                     msg = String.format("VPN with vpnid: %s does not exist", vpn.getValue());
 786                     logger.warn(msg);
 787                     error = RpcResultBuilder.newWarning(ErrorType.PROTOCOL, "invalid-value", msg);
 788                     errorList.add(error);
 789                     warningcount++;
 790                 }
 791             } catch (Exception ex) {
 792                 msg = String.format("Deletion of L3VPN failed when deleting for uuid %s", vpn.getValue());
 793                 logger.error(msg, ex);
 794                 error = RpcResultBuilder.newError(ErrorType.APPLICATION, msg, ex.getMessage());
 795                 errorList.add(error);
 796                 failurecount++;
 797             }
 798         }
 799         // if at least one succeeds; result is success
 800         // if none succeeds; result is failure
 801         if (failurecount + warningcount == vpns.size()) {
 802             result.set(RpcResultBuilder.<DeleteL3VPNOutput>failed().withRpcErrors(errorList).build());
 803         } else {
 804             List<String> errorResponseList = new ArrayList<>();
 805             if (!errorList.isEmpty()) {
 806                 for (RpcError rpcError : errorList) {
 807                     String errorResponse = String.format("ErrorType: " + rpcError.getErrorType() + ", " + "ErrorTag: " +
 808                             rpcError.getTag() + ", " + "ErrorMessage: " + rpcError.getMessage());
 809                     errorResponseList.add(errorResponse);
 810                 }
 811             } else {
 812                 errorResponseList.add("Operation successful with no errors");
 813             }
 814             opBuilder.setResponse(errorResponseList);
 815             result.set(RpcResultBuilder.<DeleteL3VPNOutput>success().withResult(opBuilder.build()).build());
 816         }
 817         return result;
 818     }
 819
 820     protected void addSubnetToVpn(Uuid vpnId, Uuid subnet) {
 821         logger.debug("Adding subnet {} to vpn {}", subnet.getValue(), vpnId.getValue());
 822         Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
 823         // Check if there are ports on this subnet and add corresponding vpn-interfaces
 824         List<Uuid> portList = sn.getPortList();
 825         if (portList != null) {
 826             for (Uuid port : sn.getPortList()) {
 827                 logger.debug("adding vpn-interface for port {}", port.getValue());
 828                 createVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(broker, port));
 829             }
 830         }
 831     }
 832
 833     protected void updateVpnForSubnet(Uuid vpnId, Uuid subnet) {
 834         logger.debug("Updating VPN {} for subnet {}", vpnId.getValue(), subnet.getValue());
 835         Subnetmap sn = updateSubnetNode(subnet, null, null, null, null, vpnId, null);
 836         // Check for ports on this subnet and update association of corresponding vpn-interfaces to external vpn
 837         List<Uuid> portList = sn.getPortList();
 838         if (portList != null) {
 839             for (Uuid port : sn.getPortList()) {
 840                 logger.debug("Updating vpn-interface for port {}", port.getValue());
 841                 updateVpnInterface(vpnId, NeutronvpnUtils.getNeutronPort(broker, port));
 842             }
 843         }
 844     }
 845
 846     protected List<Adjacency> addAdjacencyforExtraRoute(List<Routes> routeList, boolean rtrUp, String vpnifname) {
 847         List<Adjacency> adjList = new ArrayList<Adjacency>();
 848         for (Routes route : routeList) {
 849             if (route != null && route.getNexthop() != null && route.getDestination() != null) {
 850                 boolean isLockAcquired = false;
 851                 String nextHop = String.valueOf(route.getNexthop().getValue());
 852                 String destination = String.valueOf(route.getDestination().getValue());
 853
 854                 String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
 855                 logger.trace("Adding extra route with nexthop {}, destination {}, infName {}", nextHop,
 856                         destination, infName);
 857                 Adjacency erAdj = new AdjacencyBuilder().setIpAddress(destination).setNextHopIp(nextHop).setKey
 858                         (new AdjacencyKey(destination)).build();
 859                 if (rtrUp == false) {
 860                     if (infName.equals(vpnifname)) {
 861                         adjList.add(erAdj);
 862                     }
 863                     continue;
 864                 }
 865                 InstanceIdentifier<VpnInterface> vpnIfIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
 866                         child(VpnInterface.class, new VpnInterfaceKey(infName)).build();
 867                 try {
 868                     Optional<VpnInterface> optionalVpnInterface = NeutronvpnUtils.read(broker, LogicalDatastoreType
 869                             .CONFIGURATION, vpnIfIdentifier);
 870                     if (optionalVpnInterface.isPresent()) {
 871                         Adjacencies erAdjs = new AdjacenciesBuilder().setAdjacency(Arrays.asList(erAdj)).build();
 872                         VpnInterface vpnIf = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(infName))
 873                                 .addAugmentation(Adjacencies.class, erAdjs).build();
 874                         isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 875                         logger.debug("Adding extra route {}", route);
 876                         MDSALUtil.syncUpdate(broker, LogicalDatastoreType.CONFIGURATION, vpnIfIdentifier, vpnIf);
 877                     } else {
 878                         logger.error("VM adjacency for interface {} not present ; cannot add extra route adjacency",
 879                                 infName);
 880                     }
 881                 } catch (Exception e) {
 882                     logger.error("exception in adding extra route: {}" + e);
 883                 } finally {
 884                     if (isLockAcquired) {
 885                         NeutronvpnUtils.unlock(lockManager, infName);
 886                     }
 887                 }
 888             } else {
 889                 logger.error("Incorrect input received for extra route. {}", route);
 890             }
 891         }
 892         return adjList;
 893     }
 894
 895     protected void removeAdjacencyforExtraRoute(List<Routes> routeList) {
 896         for (Routes route : routeList) {
 897             if (route != null && route.getNexthop() != null && route.getDestination() != null) {
 898                 boolean isLockAcquired = false;
 899                 String nextHop = String.valueOf(route.getNexthop().getValue());
 900                 String destination = String.valueOf(route.getDestination().getValue());
 901
 902                 String infName = NeutronvpnUtils.getNeutronPortNamefromPortFixedIp(broker, nextHop);
 903                 logger.trace("Removing extra route with nexthop {}, destination {}, infName {}", nextHop,
 904                         destination, infName);
 905                 InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class).
 906                         child(VpnInterface.class, new VpnInterfaceKey(infName)).augmentation(Adjacencies.class)
 907                         .child(Adjacency.class, new AdjacencyKey(destination)).build();
 908                 try {
 909                     isLockAcquired = NeutronvpnUtils.lock(lockManager, infName);
 910                     MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
 911                     logger.trace("extra route {} deleted successfully", route);
 912                 } catch (Exception e) {
 913                     logger.error("exception in deleting extra route: {}" + e);
 914                 } finally {
 915                     if (isLockAcquired) {
 916                         NeutronvpnUtils.unlock(lockManager, infName);
 917                     }
 918                 }
 919             } else {
 920                 logger.error("Incorrect input received for extra route. {}", route);
 921             }
 922         }
 923     }
 924
 925     protected void removeL3Vpn(Uuid id) {
 926         // read VPNMaps
 927         VpnMap vpnMap = NeutronvpnUtils.getVpnMap(broker, id);
 928         Uuid router = vpnMap.getRouterId();
 929         // dissociate router
 930         if (router != null) {
 931             dissociateRouterFromVpn(id, router);
 932         }
 933         // dissociate networks
 934         if (!id.equals(router)) {
 935             dissociateNetworksFromVpn(id, vpnMap.getNetworkIds());
 936         }
 937         // remove entire vpnMaps node
 938         deleteVpnMapsNode(id);
 939
 940         // remove vpn-instance
 941         deleteVpnInstance(id);
 942     }
 943
 944     protected void removeSubnetFromVpn(Uuid vpnId, Uuid subnet) {
 945         logger.debug("Removing subnet {} from vpn {}", subnet.getValue(), vpnId.getValue());
 946         Subnetmap sn = NeutronvpnUtils.getSubnetmap(broker, subnet);
 947         if (sn != null) {
 948             // Check if there are ports on this subnet; remove corresponding vpn-interfaces
 949             List<Uuid> portList = sn.getPortList();
 950             if (portList != null) {
 951                 for (Uuid port : sn.getPortList()) {
 952                     logger.debug("removing vpn-interface for port {}", port.getValue());
 953                     deleteVpnInterface(NeutronvpnUtils.getNeutronPort(broker, port));
 954                 }
 955             }
 956             // update subnet-vpn association
 957             removeFromSubnetNode(subnet, null, null, vpnId, null);
 958         } else {
 959             logger.warn("Subnetmap for subnet {} not found", subnet.getValue());
 960         }
 961     }
 962
 963     protected void associateRouterToVpn(Uuid vpnId, Uuid routerId) {
 964         updateVpnMaps(vpnId, null, routerId, null, null);
 965         List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
 966         if (!vpnId.equals(routerId)) {
 967             logger.debug("Updating association of subnets to external vpn {}", vpnId.getValue());
 968             if (routerSubnets != null) {
 969                 for (Uuid subnetId : routerSubnets) {
 970                     updateVpnForSubnet(vpnId, subnetId);
 971                 }
 972             }
 973         } else {
 974             logger.debug("Adding subnets to internal vpn {}", vpnId.getValue());
 975             for (Uuid subnet : routerSubnets) {
 976                 addSubnetToVpn(vpnId, subnet);
 977             }
 978         }
 979     }
 980
 981     protected void dissociateRouterFromVpn(Uuid vpnId, Uuid routerId) {
 982
 983         List<Uuid> routerSubnets = NeutronvpnUtils.getNeutronRouterSubnetIds(broker, routerId);
 984         if (routerSubnets != null) {
 985             for (Uuid subnetId : routerSubnets) {
 986                 logger.debug("Updating association of subnets to internal vpn {}", routerId.getValue());
 987                 updateVpnForSubnet(routerId, subnetId);
 988             }
 989         }
 990         clearFromVpnMaps(vpnId, routerId, null);
 991     }
 992
 993     protected List<String> associateNetworksToVpn(Uuid vpn, List<Uuid> networks) {
 994         List<String> failed = new ArrayList<String>();
 995         if (!networks.isEmpty()) {
 996             // store in Data Base
 997             updateVpnMaps(vpn, null, null, null, networks);
 998             // process corresponding subnets for VPN
 999             for (Uuid nw : networks) {
1000                 if (NeutronvpnUtils.getNeutronNetwork(broker, nw) == null) {
1001                     failed.add(nw.getValue());
1002                 } else {
1003                     List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
1004                     logger.debug("Adding network subnets...");
1005                     if (networkSubnets != null) {
1006                         for (Uuid subnet : networkSubnets) {
1007                             addSubnetToVpn(vpn, subnet);
1008                         }
1009                     }
1010                 }
1011             }
1012         }
1013         return failed;
1014     }
1015
1016     protected List<String> dissociateNetworksFromVpn(Uuid vpn, List<Uuid> networks) {
1017         List<String> failed = new ArrayList<String>();
1018         if (networks != null && !networks.isEmpty()) {
1019             // store in Data Base
1020             clearFromVpnMaps(vpn, null, networks);
1021             // process corresponding subnets for VPN
1022             for (Uuid nw : networks) {
1023                 if (NeutronvpnUtils.getNeutronNetwork(broker, nw) == null) {
1024                     failed.add(nw.getValue());
1025                 } else {
1026                     List<Uuid> networkSubnets = NeutronvpnUtils.getSubnetIdsFromNetworkId(broker, nw);
1027                     logger.debug("Removing network subnets...");
1028                     if (networkSubnets != null) {
1029                         for (Uuid subnet : networkSubnets) {
1030                             removeSubnetFromVpn(vpn, subnet);
1031                         }
1032                     }
1033                 }
1034             }
1035         }
1036         return failed;
1037     }
1038
1039     @Override
1040     public Future<RpcResult<AssociateNetworksOutput>> associateNetworks(AssociateNetworksInput input) {
1041
1042         AssociateNetworksOutputBuilder opBuilder = new AssociateNetworksOutputBuilder();
1043         SettableFuture<RpcResult<AssociateNetworksOutput>> result = SettableFuture.create();
1044         logger.debug("associateNetworks {}", input);
1045         StringBuilder returnMsg = new StringBuilder();
1046         Uuid vpnId = input.getVpnId();
1047
1048         try {
1049             if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1050                 List<Uuid> netIds = input.getNetworkId();
1051                 if (netIds != null && !netIds.isEmpty()) {
1052                     List<String> failed = associateNetworksToVpn(vpnId, netIds);
1053                     if (!failed.isEmpty()) {
1054                         returnMsg.append("network(s) not found : ").append(failed);
1055                     }
1056                 }
1057             } else {
1058                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1059             }
1060             if (returnMsg.length() != 0) {
1061                 String message = String.format("associate Networks to vpn %s failed due to %s", vpnId.getValue(),
1062                         returnMsg);
1063                 logger.error(message);
1064                 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1065                         message);
1066                 opBuilder.setResponse(errorResponse);
1067                 result.set(RpcResultBuilder.<AssociateNetworksOutput>success().withResult(opBuilder.build()).build());
1068             } else {
1069                 result.set(RpcResultBuilder.<AssociateNetworksOutput>success().build());
1070             }
1071         } catch (Exception ex) {
1072             String message = String.format("associate Networks to vpn %s failed due to %s", input.getVpnId().getValue(),
1073                     ex.getMessage());
1074             logger.error(message, ex);
1075             result.set(RpcResultBuilder.<AssociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
1076                     .build());
1077         }
1078         logger.debug("associateNetworks returns..");
1079         return result;
1080     }
1081
1082     @Override
1083     public Future<RpcResult<Void>> associateRouter(AssociateRouterInput input) {
1084
1085         SettableFuture<RpcResult<Void>> result = SettableFuture.create();
1086         logger.debug("associateRouter {}", input);
1087         StringBuilder returnMsg = new StringBuilder();
1088         Uuid vpnId = input.getVpnId();
1089         Uuid routerId = input.getRouterId();
1090         try {
1091             if (routerId != null && vpnId != null) {
1092                 Router rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
1093                 VpnMap vpnMap = NeutronvpnUtils.getVpnMap(broker, vpnId);
1094                 if (rtr != null && vpnMap != null) {
1095                     if (vpnMap.getRouterId() != null) {
1096                         returnMsg.append("vpn ").append(vpnId.getValue()).append(" already associated to router ")
1097                                 .append(vpnMap.getRouterId().getValue());
1098                     } else {
1099                         associateRouterToVpn(vpnId, routerId);
1100                     }
1101                 } else {
1102                     returnMsg.append("router not found : ").append(routerId.getValue());
1103                 }
1104             } else {
1105                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1106             }
1107             if (returnMsg.length() != 0) {
1108                 String message = String.format("associate router to vpn %s failed due to %s", routerId.getValue(),
1109                         returnMsg);
1110                 logger.error(message);
1111                 result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
1112                         .build());
1113             } else {
1114                 result.set(RpcResultBuilder.<Void>success().build());
1115             }
1116         } catch (Exception ex) {
1117             String message = String.format("associate router %s to vpn %s failed due to %s", routerId.getValue(),
1118                     vpnId.getValue(), ex.getMessage());
1119             logger.error(message, ex);
1120             result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
1121         }
1122         logger.debug("associateRouter returns..");
1123         return result;
1124     }
1125
1126     @Override
1127     public Future<RpcResult<DissociateNetworksOutput>> dissociateNetworks(DissociateNetworksInput input) {
1128
1129         DissociateNetworksOutputBuilder opBuilder = new DissociateNetworksOutputBuilder();
1130         SettableFuture<RpcResult<DissociateNetworksOutput>> result = SettableFuture.create();
1131
1132         logger.debug("dissociateNetworks {}", input);
1133         StringBuilder returnMsg = new StringBuilder();
1134         Uuid vpnId = input.getVpnId();
1135
1136         try {
1137             if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1138                 List<Uuid> netIds = input.getNetworkId();
1139                 if (netIds != null && !netIds.isEmpty()) {
1140                     List<String> failed = dissociateNetworksFromVpn(vpnId, netIds);
1141                     if (!failed.isEmpty()) {
1142                         returnMsg.append("netowrk(s) not found : ").append(failed);
1143                     }
1144                 }
1145             } else {
1146                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1147             }
1148             if (returnMsg.length() != 0) {
1149                 String message = String.format("dissociate Networks to vpn %s failed due to %s", vpnId.getValue(),
1150                         returnMsg);
1151                 logger.error(message);
1152                 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1153                         message);
1154                 opBuilder.setResponse(errorResponse);
1155                 result.set(RpcResultBuilder.<DissociateNetworksOutput>success().withResult(opBuilder.build()).build());
1156             } else {
1157                 result.set(RpcResultBuilder.<DissociateNetworksOutput>success().build());
1158             }
1159         } catch (Exception ex) {
1160             String message = String.format("dissociate Networks to vpn %s failed due to %s", input.getVpnId().
1161                     getValue(), ex.getMessage());
1162             logger.error(message, ex);
1163             result.set(RpcResultBuilder.<DissociateNetworksOutput>failed().withError(ErrorType.APPLICATION, message)
1164                     .build());
1165         }
1166         logger.debug("dissociateNetworks returns..");
1167         return result;
1168     }
1169
1170     @Override
1171     public Future<RpcResult<Void>> dissociateRouter(DissociateRouterInput input) {
1172
1173         SettableFuture<RpcResult<Void>> result = SettableFuture.create();
1174
1175         logger.debug("dissociateRouter {}", input);
1176         StringBuilder returnMsg = new StringBuilder();
1177         Uuid vpnId = input.getVpnId();
1178         Uuid routerId = input.getRouterId();
1179         try {
1180             if (NeutronvpnUtils.getVpnMap(broker, vpnId) != null) {
1181                 if (routerId != null) {
1182                     Router rtr = NeutronvpnUtils.getNeutronRouter(broker, routerId);
1183                     if (rtr != null) {
1184                         dissociateRouterFromVpn(vpnId, routerId);
1185                     } else {
1186                         returnMsg.append("router not found : ").append(routerId.getValue());
1187                     }
1188                 }
1189             } else {
1190                 returnMsg.append("VPN not found : ").append(vpnId.getValue());
1191             }
1192             if (returnMsg.length() != 0) {
1193                 String message = String.format("dissociate router %s to vpn %s failed due to %s", routerId.getValue(),
1194                         vpnId.getValue(), returnMsg);
1195                 logger.error(message);
1196                 String errorResponse = String.format("ErrorType: PROTOCOL, ErrorTag: invalid-value, ErrorMessage: " +
1197                         message);
1198                 result.set(RpcResultBuilder.<Void>failed().withWarning(ErrorType.PROTOCOL, "invalid-value", message)
1199                         .build());
1200             } else {
1201                 result.set(RpcResultBuilder.<Void>success().build());
1202             }
1203         } catch (Exception ex) {
1204             String message = String.format("disssociate router %s to vpn %s failed due to %s", routerId.getValue(),
1205                     vpnId.getValue(), ex.getMessage());
1206             logger.error(message, ex);
1207             result.set(RpcResultBuilder.<Void>failed().withError(ErrorType.APPLICATION, message).build());
1208         }
1209         logger.debug("dissociateRouter returns..");
1210
1211         return result;
1212     }
1213
1214     @Override
1215     public Future<RpcResult<GetFixedIPsForNeutronPortOutput>> getFixedIPsForNeutronPort(GetFixedIPsForNeutronPortInput
1216                                                                                                 input) {
1217         GetFixedIPsForNeutronPortOutputBuilder opBuilder = new GetFixedIPsForNeutronPortOutputBuilder();
1218         SettableFuture<RpcResult<GetFixedIPsForNeutronPortOutput>> result = SettableFuture.create();
1219         Uuid portId = input.getPortId();
1220         StringBuilder returnMsg = new StringBuilder();
1221         try {
1222             List<String> fixedIPList = new ArrayList<>();
1223             Port port = NeutronvpnUtils.getNeutronPort(broker, portId);
1224             if (port != null) {
1225                 List<FixedIps> fixedIPs = port.getFixedIps();
1226                 for (FixedIps ip : fixedIPs) {
1227                     fixedIPList.add(ip.getIpAddress().getIpv4Address().getValue());
1228                 }
1229             } else {
1230                 returnMsg.append("neutron port: ").append(portId.getValue()).append(" not found");
1231             }
1232             if (returnMsg.length() != 0) {
1233                 String message = String.format("Retrieval of FixedIPList for neutron port failed due to %s", returnMsg);
1234                 logger.error(message);
1235                 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed().withWarning(ErrorType.PROTOCOL,
1236                         "invalid-value", message).build());
1237             } else {
1238                 opBuilder.setFixedIPs(fixedIPList);
1239                 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().withResult(opBuilder.build())
1240                         .build());
1241                 result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>success().build());
1242             }
1243         } catch (Exception ex) {
1244             String message = String.format("Retrieval of FixedIPList for neutron port %s failed due to %s", portId
1245                     .getValue(), ex.getMessage());
1246             logger.error(message, ex);
1247             result.set(RpcResultBuilder.<GetFixedIPsForNeutronPortOutput>failed().withError(ErrorType.APPLICATION,
1248                     message).build());
1249         }
1250         return result;
1251     }
1252
1253     protected void handleNeutronRouterDeleted(Uuid routerId, List<Uuid> routerSubnetIds) {
1254         // check if the router is associated to some VPN
1255         Uuid vpnId = NeutronvpnUtils.getVpnForRouter(broker, routerId, true);
1256         if (vpnId != null) {
1257             // remove existing external vpn interfaces
1258             for (Uuid subnetId : routerSubnetIds) {
1259                 removeSubnetFromVpn(vpnId, subnetId);
1260             }
1261             clearFromVpnMaps(vpnId, routerId, null);
1262         } else {
1263             // remove existing internal vpn interfaces
1264             for (Uuid subnetId : routerSubnetIds) {
1265                 removeSubnetFromVpn(routerId, subnetId);
1266             }
1267         }
1268         // delete entire vpnMaps node for internal VPN
1269         deleteVpnMapsNode(routerId);
1270
1271         // delete vpn-instance for internal VPN
1272         deleteVpnInstance(routerId);
1273     }
1274
1275     protected Subnet getNeutronSubnet(Uuid subnetId) {
1276         InstanceIdentifier<Subnet> inst = InstanceIdentifier.create(Neutron.class).
1277                 child(Subnets.class).child(Subnet.class, new SubnetKey(subnetId));
1278         Optional<Subnet> sn = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, inst);
1279
1280         if (sn.isPresent()) {
1281             return sn.get();
1282         }
1283         return null;
1284     }
1285
1286     protected IpAddress getNeutronSubnetGateway(Uuid subnetId) {
1287         Subnet sn = getNeutronSubnet(subnetId);
1288         if (null != sn) {
1289             return sn.getGatewayIp();
1290         }
1291         return null;
1292     }
1293
1294     protected Port getNeutronPort(String name) {
1295         return NeutronvpnUtils.getNeutronPort(broker, new Uuid(name));
1296     }
1297
1298     protected Port getNeutronPort(Uuid portId) {
1299         return NeutronvpnUtils.getNeutronPort(broker, portId);
1300     }
1301
1302     protected List<Uuid> getSubnetsforVpn(Uuid vpnid) {
1303         List<Uuid> subnets = new ArrayList<Uuid>();
1304         //read subnetmaps
1305         InstanceIdentifier<Subnetmaps> subnetmapsid = InstanceIdentifier.builder(Subnetmaps.class).build();
1306         Optional<Subnetmaps> subnetmaps = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION,
1307                 subnetmapsid);
1308         if (subnetmaps.isPresent() && subnetmaps.get().getSubnetmap() != null) {
1309             List<Subnetmap> subnetMapList = subnetmaps.get().getSubnetmap();
1310             for (Subnetmap subnetMap : subnetMapList) {
1311                 if (subnetMap.getVpnId() != null && subnetMap.getVpnId().equals(vpnid)) {
1312                     subnets.add(subnetMap.getId());
1313                 }
1314             }
1315         }
1316         return subnets;
1317     }
1318
1319     public List<String> showNeutronPortsCLI() {
1320         List<String> result = new ArrayList<String>();
1321         result.add(String.format(" %-34s  %-22s  %-22s  %-6s ", "PortName", "Mac Address", "IP Address",
1322                 "Prefix Length"));
1323         result.add("---------------------------------------------------------------------------------------");
1324         InstanceIdentifier<Ports> portidentifier = InstanceIdentifier.create(Neutron.class).child(Ports.class);
1325         try {
1326             Optional<Ports> ports = NeutronvpnUtils.read(broker, LogicalDatastoreType.CONFIGURATION, portidentifier);
1327             if (ports.isPresent() && ports.get().getPort() != null) {
1328                 List<Port> portList = ports.get().getPort();
1329                 for (Port port : portList) {
1330                     result.add(String.format(" %-34s  %-22s  %-22s  %-6s ", port.getUuid().getValue(), port
1331                             .getMacAddress(), port.getFixedIps().get(0).getIpAddress().getIpv4Address().getValue(),
1332                             NeutronvpnUtils.getIPPrefixFromPort(broker, port)));
1333                 }
1334             }
1335         } catch (Exception e) {
1336             logger.error("Failed to retrieve neutronPorts info : ", e);
1337             System.out.println("Failed to retrieve neutronPorts info : " + e.getMessage());
1338         }
1339         return result;
1340     }
1341
1342     public List<String> showVpnConfigCLI(Uuid vpnuuid) {
1343         List<String> result = new ArrayList<String>();
1344         if (vpnuuid == null) {
1345             System.out.println("");
1346             System.out.println("Displaying VPN config for all VPNs");
1347             System.out.println("To display VPN config for a particular VPN, use the following syntax");
1348             System.out.println(getshowVpnConfigCLIHelp());
1349         }
1350         try {
1351             RpcResult<GetL3VPNOutput> rpcResult = getL3VPN(new GetL3VPNInputBuilder().setId(vpnuuid).build()).get();
1352             if (rpcResult.isSuccessful()) {
1353                 result.add("");
1354                 result.add(String.format(" %-37s %-37s %-7s ", "VPN ID", "Tenant ID", "RD"));
1355                 result.add("");
1356                 result.add(String.format(" %-80s ", "Import-RTs"));
1357                 result.add("");
1358                 result.add(String.format(" %-80s ", "Export-RTs"));
1359                 result.add("");
1360                 result.add(String.format(" %-76s ", "Subnet IDs"));
1361                 result.add("");
1362                 result.add("------------------------------------------------------------------------------------");
1363                 result.add("");
1364                 List<L3vpnInstances> VpnList = rpcResult.getResult().getL3vpnInstances();
1365                 for (L3vpnInstance Vpn : VpnList) {
1366                     String tenantId = Vpn.getTenantId() != null ? Vpn.getTenantId().getValue() : "\"                 " +
1367                             "                  \"";
1368                     result.add(String.format(" %-37s %-37s %-7s ", Vpn.getId().getValue(), tenantId, Vpn
1369                             .getRouteDistinguisher()));
1370                     result.add("");
1371                     result.add(String.format(" %-80s ", Vpn.getImportRT()));
1372                     result.add("");
1373                     result.add(String.format(" %-80s ", Vpn.getExportRT()));
1374                     result.add("");
1375
1376                     Uuid vpnid = Vpn.getId();
1377                     List<Uuid> subnetList = getSubnetsforVpn(vpnid);
1378                     if (!subnetList.isEmpty()) {
1379                         for (Uuid subnetuuid : subnetList) {
1380                             result.add(String.format(" %-76s ", subnetuuid.getValue()));
1381                         }
1382                     } else {
1383                         result.add(String.format(" %-76s ", "\"                                    \""));
1384                     }
1385                     result.add("");
1386                     result.add("----------------------------------------");
1387                     result.add("");
1388                 }
1389             } else {
1390                 String errortag = rpcResult.getErrors().iterator().next().getTag();
1391                 if (errortag == "") {
1392                     System.out.println("");
1393                     System.out.println("No VPN has been configured yet");
1394                 } else if (errortag == "invalid-value") {
1395                     System.out.println("");
1396                     System.out.println("VPN " + vpnuuid.getValue() + " is not present");
1397                 } else {
1398                     System.out.println("error getting VPN info : " + rpcResult.getErrors());
1399                     System.out.println(getshowVpnConfigCLIHelp());
1400                 }
1401             }
1402         } catch (InterruptedException | ExecutionException e) {
1403             logger.error("error getting VPN info : ", e);
1404             System.out.println("error getting VPN info : " + e.getMessage());
1405         }
1406         return result;
1407     }
1408
1409     private String getshowVpnConfigCLIHelp() {
1410         StringBuilder help = new StringBuilder("Usage:");
1411         help.append("display vpn-config [-vid/--vpnid <id>]");
1412         return help.toString();
1413     }
1414
1415 }