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