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