vpnservice/vpnmanager/vpnmanager-impl/src/main/java/org/opendaylight/netvirt/vpnmanager/VpnUtil.java

   1 /*
   2  * Copyright (c) 2015 - 2016 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.netvirt.vpnmanager;
  10
  11 import java.math.BigInteger;
  12 import java.net.InetAddress;
  13 import java.util.*;
  14 import java.util.concurrent.ExecutionException;
  15 import java.util.concurrent.Future;
  16
  17
  18 import com.google.common.base.Optional;
  19 import com.google.common.base.Preconditions;
  20 import com.google.common.primitives.Ints;
  21 import com.google.common.util.concurrent.CheckedFuture;
  22 import com.google.common.util.concurrent.FutureCallback;
  23 import com.google.common.util.concurrent.Futures;
  24
  25 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  26 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  27 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  28 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  29 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  30 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  31 import org.opendaylight.genius.mdsalutil.NwConstants;
  32 import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
  33 import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
  34 import org.opendaylight.netvirt.neutronvpn.api.utils.NeutronConstants;
  35 import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
  36 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.bgp.rev130715.bgp.neighbors.bgp.neighbor.peer.address.type.IpAddress;
  37 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
  38 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  39 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  40 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  41 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  42 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  43 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  44 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  47 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanTagNameMap;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagName;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagNameKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.*;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIds;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsKey;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesKey;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceKey;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.Vpn;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.VpnBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.VpnKey;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.vpn.Extraroute;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroute.vpn.ExtrarouteKey;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.L3nexthop;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthops;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortipPortData;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortBuilder;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortKey;
 109 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
 110 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
 111 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
 112 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
 113 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinkStates;
 114 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.InterVpnLinks;
 115 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkState;
 116 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkStateKey;
 117 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.links.InterVpnLink;
 118 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 119
 120 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap;
 121 import org.opendaylight.yangtools.yang.common.RpcResult;
 122 import org.opendaylight.yangtools.yang.binding.DataObject;
 123 import org.opendaylight.yangtools.yang.data.impl.schema.tree.SchemaValidationFailedException;
 124 import org.slf4j.Logger;
 125 import org.slf4j.LoggerFactory;
 126
 127 public class VpnUtil {
 128     private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
 129     private static final int DEFAULT_PREFIX_LENGTH = 32;
 130     private static final String PREFIX_SEPARATOR = "/";
 131
 132     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
 133         return InstanceIdentifier.builder(VpnInterfaces.class)
 134                 .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
 135     }
 136
 137     static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
 138         return InstanceIdentifier.builder(VpnInstances.class)
 139                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 140     }
 141
 142     static VpnInterface getVpnInterface(String intfName, String vpnName, Adjacencies aug, BigInteger dpnId, Boolean isSheduledForRemove) {
 143         return new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(intfName)).setVpnInstanceName(vpnName).setDpnId(dpnId)
 144                 .setScheduledForRemove(isSheduledForRemove).addAugmentation(Adjacencies.class, aug)
 145                 .build();
 146     }
 147
 148     static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(long vpnId, String ipPrefix) {
 149         return InstanceIdentifier.builder(PrefixToInterface.class)
 150                 .child(VpnIds.class, new VpnIdsKey(vpnId)).child(Prefixes.class,
 151                         new PrefixesKey(ipPrefix)).build();
 152     }
 153
 154     static InstanceIdentifier<VpnIds> getPrefixToInterfaceIdentifier(long vpnId) {
 155         return InstanceIdentifier.builder(PrefixToInterface.class)
 156                 .child(VpnIds.class, new VpnIdsKey(vpnId)).build();
 157     }
 158
 159     static VpnIds getPrefixToInterface(long vpnId) {
 160         return new VpnIdsBuilder().setKey(new VpnIdsKey(vpnId)).setVpnId(vpnId).build();
 161     }
 162
 163     static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix) {
 164         return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
 165                 vpnInterfaceName).setIpAddress(ipPrefix).build();
 166     }
 167
 168     static InstanceIdentifier<Extraroute> getVpnToExtrarouteIdentifier(String vrfId, String ipPrefix) {
 169         return InstanceIdentifier.builder(VpnToExtraroute.class)
 170                 .child(Vpn.class, new VpnKey(vrfId)).child(Extraroute.class,
 171                         new ExtrarouteKey(ipPrefix)).build();
 172     }
 173
 174     static InstanceIdentifier<Vpn> getVpnToExtrarouteIdentifier(String vrfId) {
 175         return InstanceIdentifier.builder(VpnToExtraroute.class)
 176                 .child(Vpn.class, new VpnKey(vrfId)).build();
 177     }
 178
 179     static Vpn getVpnToExtraRoute(String vrfId) {
 180         return new VpnBuilder().setKey(new VpnKey(vrfId)).setVrfId(vrfId).build();
 181     }
 182
 183     /**
 184      * Get VRF table given a Route Distinguisher
 185      *
 186      * @param broker dataBroker service reference
 187      * @param rd Route-Distinguisher
 188      * @return VrfTables that holds the list of VrfEntries of the specified rd
 189      */
 190     public static VrfTables getVrfTable(DataBroker broker, String rd) {
 191         InstanceIdentifier<VrfTables> id =
 192                 InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 193         Optional<VrfTables> vrfTable = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 194         return vrfTable.isPresent() ? vrfTable.get() : null;
 195     }
 196
 197     /**
 198      * Retrieves the VrfEntries that belong to a given VPN filtered out by
 199      * Origin, searching by its Route-Distinguisher
 200      *
 201      * @param broker dataBroker service reference
 202      * @param rd     Route-distinguisher of the VPN
 203      * @param originsToConsider Only entries whose origin is included in this
 204      *     list will be considered
 205      * @return the list of VrfEntries
 206      */
 207     public static List<VrfEntry> getVrfEntriesByOrigin(DataBroker broker, String rd,
 208                                                        List<RouteOrigin> originsToConsider) {
 209         List<VrfEntry> result = new ArrayList<VrfEntry>();
 210         List<VrfEntry> allVpnVrfEntries = getAllVrfEntries(broker, rd);
 211         for (VrfEntry vrfEntry : allVpnVrfEntries) {
 212             if (originsToConsider.contains(RouteOrigin.value(vrfEntry.getOrigin()))) {
 213                 result.add(vrfEntry);
 214             }
 215         }
 216         return result;
 217     }
 218
 219     static List<Prefixes> getAllPrefixesToInterface(DataBroker broker, long vpnId) {
 220         Optional<VpnIds> vpnIds = read(broker, LogicalDatastoreType.OPERATIONAL, getPrefixToInterfaceIdentifier(vpnId));
 221         if (vpnIds.isPresent()) {
 222             return vpnIds.get().getPrefixes();
 223         }
 224         return new ArrayList<Prefixes>();
 225     }
 226
 227     static List<Extraroute> getAllExtraRoutes(DataBroker broker, String vrfId) {
 228         Optional<Vpn> extraRoutes = read(broker, LogicalDatastoreType.OPERATIONAL, getVpnToExtrarouteIdentifier(vrfId));
 229         if (extraRoutes.isPresent()) {
 230             return extraRoutes.get().getExtraroute();
 231         }
 232         return new ArrayList<Extraroute>();
 233     }
 234
 235     /**
 236      * Retrieves all the VrfEntries that belong to a given VPN searching by its
 237      * Route-Distinguisher
 238      *
 239      * @param broker dataBroker service reference
 240      * @param rd     Route-distinguisher of the VPN
 241      * @return the list of VrfEntries
 242      */
 243     public static List<VrfEntry> getAllVrfEntries(DataBroker broker, String rd) {
 244         VrfTables vrfTables = VpnUtil.getVrfTable(broker, rd);
 245         return (vrfTables != null) ? vrfTables.getVrfEntry() : new ArrayList<VrfEntry>();
 246     }
 247
 248     //FIXME: Implement caches for DS reads
 249     public static VpnInstance getVpnInstance(DataBroker broker, String vpnInstanceName) {
 250         InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,
 251                 new VpnInstanceKey(vpnInstanceName)).build();
 252         Optional<VpnInstance> vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 253         return (vpnInstance.isPresent()) ? vpnInstance.get() : null;
 254     }
 255
 256     static List<VpnInstance> getAllVpnInstance(DataBroker broker) {
 257         InstanceIdentifier<VpnInstances> id = InstanceIdentifier.builder(VpnInstances.class).build();
 258         Optional<VpnInstances> optVpnInstances = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 259         if (optVpnInstances.isPresent()) {
 260             return optVpnInstances.get().getVpnInstance();
 261         } else {
 262             return new ArrayList<VpnInstance>();
 263         }
 264     }
 265
 266     static VrfEntry getVrfEntry(DataBroker broker, String rd, String ipPrefix) {
 267
 268         VrfTables vrfTable = getVrfTable(broker, rd);
 269         // TODO: why check VrfTables if we later go for the specific VrfEntry?
 270         if (vrfTable != null) {
 271             InstanceIdentifier<VrfEntry> vrfEntryId =
 272                     InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).
 273                             child(VrfEntry.class, new VrfEntryKey(ipPrefix)).build();
 274             Optional<VrfEntry> vrfEntry = read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
 275             if (vrfEntry.isPresent()) {
 276                 return (vrfEntry.get());
 277             }
 278         }
 279         return null;
 280     }
 281
 282     static List<Adjacency> getAdjacenciesForVpnInterfaceFromConfig(DataBroker broker, String intfName) {
 283         final InstanceIdentifier<VpnInterface> identifier = getVpnInterfaceIdentifier(intfName);
 284         InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
 285         Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
 286
 287         if (adjacencies.isPresent()) {
 288             List<Adjacency> nextHops = adjacencies.get().getAdjacency();
 289             return nextHops;
 290         }
 291         return null;
 292     }
 293
 294     static Extraroute getVpnToExtraroute(String ipPrefix, List<String> nextHopList) {
 295         return new ExtrarouteBuilder().setPrefix(ipPrefix).setNexthopIpList(nextHopList).build();
 296     }
 297
 298     public static List<Extraroute> getVpnExtraroutes(DataBroker broker, String vpnRd) {
 299         InstanceIdentifier<Vpn> vpnExtraRoutesId =
 300                 InstanceIdentifier.builder(VpnToExtraroute.class).child(Vpn.class, new VpnKey(vpnRd)).build();
 301         Optional<Vpn> vpnOpc = read(broker, LogicalDatastoreType.OPERATIONAL, vpnExtraRoutesId);
 302         return vpnOpc.isPresent() ? vpnOpc.get().getExtraroute() : new ArrayList<Extraroute>();
 303     }
 304
 305     static Adjacencies getVpnInterfaceAugmentation(List<Adjacency> nextHopList) {
 306         return new AdjacenciesBuilder().setAdjacency(nextHopList).build();
 307     }
 308
 309     public static InstanceIdentifier<IdPool> getPoolId(String poolName) {
 310         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 311                 InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 312         InstanceIdentifier<IdPool> id = idBuilder.build();
 313         return id;
 314     }
 315
 316     static InstanceIdentifier<VpnInterfaces> getVpnInterfacesIdentifier() {
 317         return InstanceIdentifier.builder(VpnInterfaces.class).build();
 318     }
 319
 320     static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
 321         return InstanceIdentifier.builder(Interfaces.class)
 322                 .child(Interface.class, new InterfaceKey(interfaceName)).build();
 323     }
 324
 325     static InstanceIdentifier<VpnToDpnList> getVpnToDpnListIdentifier(String rd, BigInteger dpnId) {
 326         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 327                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd))
 328                 .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId)).build();
 329     }
 330
 331     public static BigInteger getCookieArpFlow(int interfaceTag) {
 332         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0110000", 16)).add(
 333                 BigInteger.valueOf(interfaceTag));
 334     }
 335
 336     public static BigInteger getCookieL3(int vpnId) {
 337         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0610000", 16)).add(BigInteger.valueOf(vpnId));
 338     }
 339
 340     public static String getFlowRef(BigInteger dpnId, short tableId, int ethType, int lPortTag, int arpType) {
 341         return new StringBuffer().append(VpnConstants.FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 342                 .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(ethType).append(lPortTag)
 343                 .append(NwConstants.FLOWID_SEPARATOR).append(arpType).toString();
 344     }
 345
 346     public static int getUniqueId(IdManagerService idManager, String poolName, String idKey) {
 347         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 348
 349         try {
 350             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 351             RpcResult<AllocateIdOutput> rpcResult = result.get();
 352             if (rpcResult.isSuccessful()) {
 353                 return rpcResult.getResult().getIdValue().intValue();
 354             } else {
 355                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 356             }
 357         } catch (InterruptedException | ExecutionException e) {
 358             LOG.warn("Exception when getting Unique Id", e);
 359         }
 360         return 0;
 361     }
 362
 363     public static void releaseId(IdManagerService idManager, String poolName, String idKey) {
 364         ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 365         try {
 366             Future<RpcResult<Void>> result = idManager.releaseId(idInput);
 367             RpcResult<Void> rpcResult = result.get();
 368             if (!rpcResult.isSuccessful()) {
 369                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 370             }
 371         } catch (InterruptedException | ExecutionException e) {
 372             LOG.warn("Exception when getting Unique Id for key {}", idKey, e);
 373         }
 374     }
 375
 376     public static String getNextHopLabelKey(String rd, String prefix) {
 377         return rd + VpnConstants.SEPARATOR + prefix;
 378     }
 379
 380     /**
 381      * Retrieves the VpnInstance name (typically the VPN Uuid) out from the
 382      * route-distinguisher
 383      *
 384      * @param broker dataBroker service reference
 385      * @param rd Route-Distinguisher
 386      * @return the VpnInstance name
 387      */
 388     public static String getVpnNameFromRd(DataBroker broker, String rd) {
 389         VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(broker, rd);
 390         return (vpnInstanceOpData != null) ? vpnInstanceOpData.getVpnInstanceName() : null;
 391     }
 392
 393     /**
 394      * Retrieves the dataplane identifier of a specific VPN, searching by its
 395      * VpnInstance name.
 396      *
 397      * @param broker dataBroker service reference
 398      * @param vpnName Name of the VPN
 399      * @return the dataplane identifier of the VPN, the VrfTag.
 400      */
 401     public static long getVpnId(DataBroker broker, String vpnName) {
 402
 403         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 404                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 405         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 406                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 407
 408         long vpnId = VpnConstants.INVALID_ID;
 409         if (vpnInstance.isPresent()) {
 410             vpnId = vpnInstance.get().getVpnId();
 411         }
 412         return vpnId;
 413     }
 414
 415     /**
 416      * Retrieves the VPN Route Distinguisher searching by its Vpn instance name
 417      *
 418      * @param broker dataBroker service reference
 419      * @param vpnName Name of the VPN
 420      * @return the route-distinguisher of the VPN
 421      */
 422     public static String getVpnRd(DataBroker broker, String vpnName) {
 423         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> id
 424                 = getVpnInstanceToVpnIdIdentifier(vpnName);
 425         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance> vpnInstance
 426                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 427
 428         String rd = null;
 429         if (vpnInstance.isPresent()) {
 430             rd = vpnInstance.get().getVrfId();
 431         }
 432         return rd;
 433     }
 434
 435     /**
 436      * Get VPN Route Distinguisher from VPN Instance Configuration
 437      *
 438      * @param broker dataBroker service reference
 439      * @param vpnName Name of the VPN
 440      * @return the route-distinguisher of the VPN
 441      */
 442     public static String getVpnRdFromVpnInstanceConfig(DataBroker broker, String vpnName) {
 443         InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
 444                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 445         Optional<VpnInstance> vpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 446         String rd = null;
 447         if (vpnInstance.isPresent()) {
 448             VpnInstance instance = vpnInstance.get();
 449             VpnAfConfig config = instance.getIpv4Family();
 450             rd = config.getRouteDistinguisher();
 451         }
 452         return rd;
 453     }
 454
 455     /**
 456      * Remove from MDSAL all those VrfEntries in a VPN that have an specific RouteOrigin
 457      *
 458      * @param broker dataBroker service reference
 459      * @param rd     Route Distinguisher
 460      * @param origin Origin of the Routes to be removed (see {@link RouteOrigin})
 461      */
 462     public static void removeVrfEntriesByOrigin(DataBroker broker, String rd, RouteOrigin origin) {
 463         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 464                 InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 465         Optional<VrfTables> vrfTablesOpc = read(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
 466         if (vrfTablesOpc.isPresent()) {
 467             VrfTables vrfTables = vrfTablesOpc.get();
 468             List<VrfEntry> newVrfEntries = new ArrayList<VrfEntry>();
 469             for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
 470                 if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
 471                     delete(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid.child(VrfEntry.class,
 472                             vrfEntry.getKey()));
 473                 }
 474             }
 475         }
 476     }
 477
 478     public static void removeVrfEntriesByNexthop(DataBroker broker, String rd, String nexthop) {
 479         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 480                 InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 481         Optional<VrfTables> vrfTablesOpc = read(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
 482         if (vrfTablesOpc.isPresent()) {
 483             VrfTables vrfTables = vrfTablesOpc.get();
 484             for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
 485                 if (vrfEntry.getNextHopAddressList() != null && vrfEntry.getNextHopAddressList().contains(nexthop)) {
 486                     // TODO: Removes all the VrfEntry if one of the nexthops is the specified nexthop
 487                     //                should we only remove the specific nexthop, or all the VrfEnry?
 488                     delete(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid.child(VrfEntry.class,
 489                             vrfEntry.getKey()));
 490                 }
 491             }
 492         }
 493     }
 494
 495     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
 496                 getVpnInstanceToVpnId(String vpnName, long vpnId, String rd) {
 497
 498         return new VpnInstanceBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
 499
 500     }
 501
 502     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance>
 503                 getVpnInstanceToVpnIdIdentifier(String vpnName) {
 504         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
 505                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance.class,
 506                         new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceKey(vpnName)).build();
 507     }
 508
 509     static RouterInterface getConfiguredRouterInterface(DataBroker broker, String interfaceName) {
 510         Optional<RouterInterface> optRouterInterface = read(broker, LogicalDatastoreType.CONFIGURATION, VpnUtil.getRouterInterfaceId(interfaceName));
 511         if(optRouterInterface.isPresent()) {
 512             return optRouterInterface.get();
 513         }
 514         return null;
 515     }
 516
 517     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
 518                 getVpnIdToVpnInstance(long vpnId, String vpnName, String rd, boolean isExternalVpn) {
 519         return new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIdsBuilder()
 520                 .setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).setExternalVpn(isExternalVpn).build();
 521
 522     }
 523
 524     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
 525         getVpnIdToVpnInstanceIdentifier(long vpnId) {
 526         return InstanceIdentifier.builder(VpnIdToVpnInstance.class)
 527                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds.class,
 528                         new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIdsKey(Long.valueOf(vpnId))).build();
 529     }
 530
 531     /**
 532      * Retrieves the Vpn Name searching by its VPN Tag.
 533      *
 534      * @param broker dataBroker service reference
 535      * @param vpnId Dataplane identifier of the VPN
 536      * @return the Vpn instance name
 537      */
 538     public static String getVpnName(DataBroker broker, long vpnId) {
 539
 540         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds> id
 541                 = getVpnIdToVpnInstanceIdentifier(vpnId);
 542         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds> vpnInstance
 543                 = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 544
 545         String vpnName = null;
 546         if (vpnInstance.isPresent()) {
 547             vpnName = vpnInstance.get().getVpnInstanceName();
 548         }
 549         return vpnName;
 550     }
 551
 552     public static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 553         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 554                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 555     }
 556
 557     static InstanceIdentifier<RouterInterface> getRouterInterfaceId(String interfaceName) {
 558         return InstanceIdentifier.builder(RouterInterfaces.class)
 559                 .child(RouterInterface.class, new RouterInterfaceKey(interfaceName)).build();
 560     }
 561
 562     static RouterInterface getRouterInterface(String interfaceName, String routerName) {
 563         return new RouterInterfaceBuilder().setKey(new RouterInterfaceKey(interfaceName))
 564                 .setInterfaceName(interfaceName).setRouterName(routerName).build();
 565     }
 566
 567     static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
 568         InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
 569         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData = read(broker, LogicalDatastoreType.OPERATIONAL, id);
 570         if (vpnInstanceOpData.isPresent()) {
 571             return vpnInstanceOpData.get();
 572         }
 573         return null;
 574     }
 575
 576     static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
 577         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 578         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 579
 580         if (configuredVpnInterface.isPresent()) {
 581             return configuredVpnInterface.get();
 582         }
 583         return null;
 584     }
 585
 586     static String getNeutronRouterFromInterface(DataBroker broker, String interfaceName) {
 587         InstanceIdentifier.InstanceIdentifierBuilder<RouterInterfacesMap> idBuilder =
 588                             InstanceIdentifier.builder(RouterInterfacesMap.class);
 589         InstanceIdentifier<RouterInterfacesMap> id = idBuilder.build();
 590         Optional<RouterInterfacesMap> RouterInterfacesMap = MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 591         if (RouterInterfacesMap.isPresent()) {
 592                List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfaces> rtrInterfaces = RouterInterfacesMap.get().getRouterInterfaces();
 593                   for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.RouterInterfaces rtrInterface : rtrInterfaces) {
 594                       List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.Interfaces> rtrIfc = rtrInterface.getInterfaces();
 595                       for(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map.router.interfaces.Interfaces ifc : rtrIfc)
 596                        if (ifc.getInterfaceId().equals(interfaceName)) {
 597                           return rtrInterface.getRouterId().getValue();
 598                        }
 599                   }
 600         }
 601         return null;
 602     }
 603
 604     static VpnInterface getOperationalVpnInterface(DataBroker broker, String interfaceName) {
 605         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 606         Optional<VpnInterface> operationalVpnInterface = read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
 607
 608         if (operationalVpnInterface.isPresent()) {
 609             return operationalVpnInterface.get();
 610         }
 611         return null;
 612     }
 613
 614     static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName) {
 615         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 616         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 617
 618         if (configuredVpnInterface.isPresent()) {
 619             return true;
 620         }
 621         return false;
 622     }
 623
 624     static String getIpPrefix(String prefix) {
 625         String prefixValues[] = prefix.split("/");
 626         if (prefixValues.length == 1) {
 627             prefix = prefix + PREFIX_SEPARATOR + DEFAULT_PREFIX_LENGTH;
 628         }
 629         return prefix;
 630     }
 631
 632     static final FutureCallback<Void> DEFAULT_CALLBACK =
 633             new FutureCallback<Void>() {
 634                 @Override
 635                 public void onSuccess(Void result) {
 636                     LOG.debug("Success in Datastore operation");
 637                 }
 638
 639                 @Override
 640                 public void onFailure(Throwable error) {
 641                     LOG.error("Error in Datastore operation", error);
 642                 }
 643
 644                 ;
 645             };
 646
 647     public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
 648                                                           InstanceIdentifier<T> path) {
 649
 650         ReadOnlyTransaction tx = broker.newReadOnlyTransaction();
 651
 652         Optional<T> result = Optional.absent();
 653         try {
 654             result = tx.read(datastoreType, path).get();
 655         } catch (Exception e) {
 656             throw new RuntimeException(e);
 657         } finally {
 658             tx.close();
 659         }
 660
 661         return result;
 662     }
 663
 664     public static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 665                                                           InstanceIdentifier<T> path, T data) {
 666         asyncUpdate(broker, datastoreType, path, data, DEFAULT_CALLBACK);
 667     }
 668
 669     public static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 670                                                           InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 671         WriteTransaction tx = broker.newWriteOnlyTransaction();
 672         tx.merge(datastoreType, path, data, true);
 673         Futures.addCallback(tx.submit(), callback);
 674     }
 675
 676     public static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 677                                                          InstanceIdentifier<T> path, T data) {
 678         asyncWrite(broker, datastoreType, path, data, DEFAULT_CALLBACK);
 679     }
 680
 681     public static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 682                                                          InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 683         WriteTransaction tx = broker.newWriteOnlyTransaction();
 684         tx.put(datastoreType, path, data, true);
 685         Futures.addCallback(tx.submit(), callback);
 686     }
 687
 688     public static <T extends DataObject> void tryDelete(DataBroker broker, LogicalDatastoreType datastoreType,
 689                                                      InstanceIdentifier<T> path) {
 690         try {
 691             delete(broker, datastoreType, path, DEFAULT_CALLBACK);
 692         } catch ( SchemaValidationFailedException sve ) {
 693             LOG.info("Could not delete {}. SchemaValidationFailedException: {}", path, sve.getMessage());
 694         } catch ( Exception e) {
 695             LOG.info("Could not delete {}. Unhandled error: {}", path, e.getMessage());
 696         }
 697     }
 698
 699     public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
 700                                                      InstanceIdentifier<T> path) {
 701         delete(broker, datastoreType, path, DEFAULT_CALLBACK);
 702     }
 703
 704
 705     public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
 706                                                      InstanceIdentifier<T> path, FutureCallback<Void> callback) {
 707         WriteTransaction tx = broker.newWriteOnlyTransaction();
 708         tx.delete(datastoreType, path);
 709         Futures.addCallback(tx.submit(), callback);
 710     }
 711
 712     public static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 713                                                         InstanceIdentifier<T> path, T data) {
 714         WriteTransaction tx = broker.newWriteOnlyTransaction();
 715         tx.put(datastoreType, path, data, true);
 716         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 717         try {
 718             futures.get();
 719         } catch (InterruptedException | ExecutionException e) {
 720             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 721             throw new RuntimeException(e.getMessage());
 722         }
 723     }
 724
 725     public static <T extends DataObject> void syncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 726                                                          InstanceIdentifier<T> path, T data) {
 727         WriteTransaction tx = broker.newWriteOnlyTransaction();
 728         tx.merge(datastoreType, path, data, true);
 729         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 730         try {
 731             futures.get();
 732         } catch (InterruptedException | ExecutionException e) {
 733             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 734             throw new RuntimeException(e.getMessage());
 735         }
 736     }
 737
 738     public static long getRemoteBCGroup(long elanTag) {
 739         return VpnConstants.ELAN_GID_MIN + ((elanTag % VpnConstants.ELAN_GID_MIN) * 2);
 740     }
 741
 742     // interface-index-tag operational container
 743     public static IfIndexInterface getInterfaceInfoByInterfaceTag(DataBroker broker, long interfaceTag) {
 744         InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
 745         Optional<IfIndexInterface> existingInterfaceInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
 746         if (existingInterfaceInfo.isPresent()) {
 747             return existingInterfaceInfo.get();
 748         }
 749         return null;
 750     }
 751
 752     private static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
 753         return InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class,
 754                 new IfIndexInterfaceKey((int) interfaceTag)).build();
 755     }
 756
 757     public static ElanTagName getElanInfoByElanTag(DataBroker broker, long elanTag) {
 758         InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
 759         Optional<ElanTagName> existingElanInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanId);
 760         if (existingElanInfo.isPresent()) {
 761             return existingElanInfo.get();
 762         }
 763         return null;
 764     }
 765
 766     private static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
 767         return InstanceIdentifier.builder(ElanTagNameMap.class).child(ElanTagName.class,
 768                 new ElanTagNameKey(elanTag)).build();
 769     }
 770
 771
 772     // TODO: Move this to NwUtil
 773     public static boolean isIpInSubnet(int ipAddress, String subnetCidr) {
 774         String[] subSplit = subnetCidr.split("/");
 775         if (subSplit.length < 2) {
 776             return false;
 777         }
 778
 779         String subnetStr = subSplit[0];
 780         int subnet = 0;
 781         try {
 782             InetAddress subnetAddress = InetAddress.getByName(subnetStr);
 783             subnet = Ints.fromByteArray(subnetAddress.getAddress());
 784         } catch (Exception ex) {
 785             LOG.error("Passed in Subnet IP string not convertible to InetAdddress " + subnetStr);
 786             return false;
 787         }
 788         int prefixLength = Integer.valueOf(subSplit[1]);
 789         int mask = -1 << (32 - prefixLength);
 790         if ((subnet & mask) == (ipAddress & mask)) {
 791             return true;
 792         }
 793         return false;
 794     }
 795
 796     /**
 797      * Returns the Path identifier to reach a specific interface in a specific DPN in a given VpnInstance
 798      *
 799      * @param vpnRd     Route-Distinguisher of the VpnInstance
 800      * @param dpnId     Id of the DPN where the interface is
 801      * @param ifaceName Interface name
 802      * @return the Instance Identifier
 803      */
 804     public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 805             .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces>
 806     getVpnToDpnInterfacePath(String vpnRd, BigInteger dpnId, String ifaceName) {
 807
 808         return
 809                 InstanceIdentifier.builder(VpnInstanceOpData.class)
 810                         .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(vpnRd))
 811                         .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId))
 812                         .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 813                                 .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
 814                                 new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 815                                         .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfacesKey(ifaceName))
 816                         .build();
 817     }
 818
 819     /**
 820      * Includes a DPN with the corresponding interface names in the VpnToDpn operational data.
 821      * This method is preferably over mergeDpnInVpnToDpnMap(DataBroker, String, String, BigInteger, List)
 822      * when there are several DPNs to be merged since it saves some readings from MDSAL.
 823      *
 824      * @param broker     dataBroker service reference
 825      * @param vpnOpData  Reference to the object that holds the Operational data of the VpnInstance
 826      * @param dpnId      Id of the DPN where the interfaces to be added to Operational data are located
 827      * @param ifaceNames List of interface names
 828      */
 829     public static void mergeDpnInVpnToDpnMap(DataBroker broker, VpnInstanceOpDataEntry vpnOpData, BigInteger dpnId,
 830                                              List<String> ifaceNames) {
 831         Preconditions.checkNotNull(vpnOpData);
 832         Preconditions.checkNotNull(ifaceNames);
 833
 834         for (String ifaceName : ifaceNames) {
 835             InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 836                     .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> vpnDpnIfaceIid =
 837                     getVpnToDpnInterfacePath(vpnOpData.getKey().getVrfId(), dpnId, ifaceName);
 838
 839             org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 840                     .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces vpnDpnIface =
 841                     new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 842                             .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list
 843                             .VpnInterfacesBuilder().setKey(new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 844                             .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfacesKey(ifaceName))
 845                             .setInterfaceName(ifaceName)
 846                             .build();
 847
 848             syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, vpnDpnIfaceIid, vpnDpnIface);
 849         }
 850     }
 851
 852     /**
 853      * Includes a DPN with the corresponding interface names in the VpnToDpn operational data.
 854      *
 855      * @param broker dataBroker service reference
 856      * @param vpnName Name of the VPN
 857      * @param rd Route-Distinguisher
 858      * @param dpnId Id of the DPN that includes the list of Ifaces to be
 859      *           included in the Map
 860      * @param ifaceNames List of interfaces to be included in the Map
 861      */
 862     public static void mergeDpnInVpnToDpnMap(DataBroker broker, String vpnName, String rd, BigInteger dpnId,
 863                                              List<String> ifaceNames) {
 864         InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier.builder(VpnInstanceOpData.class)
 865                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(vpnName))
 866                 .build();
 867
 868         Optional<VpnInstanceOpDataEntry> vpnInstanceOpData =
 869             MDSALUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
 870         if (vpnInstanceOpData.isPresent()) {
 871             mergeDpnInVpnToDpnMap(broker, vpnInstanceOpData.get(), dpnId, ifaceNames);
 872         }
 873     }
 874
 875     /**
 876      * Removes a specific interface from the VpnToDpn operative map.
 877      *
 878      * @param broker    dataBroker service reference
 879      * @param rd        Route-distinguisher of the VPN
 880      * @param dpnId     Id of the DPN where the interface is
 881      * @param ifaceName interface name.
 882      */
 883     public static void removeIfaceFromVpnToDpnMap(DataBroker broker, String rd, BigInteger dpnId, String ifaceName) {
 884         tryDelete(broker, LogicalDatastoreType.CONFIGURATION, getVpnToDpnInterfacePath(rd, dpnId, ifaceName));
 885         // Note: tryDelete is a best-effort. Sometimes we want to update the VpnToDpnMap ifaces when the
 886         // DPN has gone down (and the VpnToDpnMap has been removed in a different Thread)
 887     }
 888
 889     public static void removePrefixToInterfaceForVpnId(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
 890         try {
 891             // Clean up PrefixToInterface Operational DS
 892             if (writeTxn != null) {
 893                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
 894                         InstanceIdentifier.builder(PrefixToInterface.class).child(
 895                                 VpnIds.class, new VpnIdsKey(vpnId)).build());
 896             } else {
 897                 delete(broker, LogicalDatastoreType.OPERATIONAL,
 898                         InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build(),
 899                         DEFAULT_CALLBACK);
 900             }
 901         } catch (Exception e) {
 902             LOG.error("Exception during cleanup of PrefixToInterface for VPN ID {}", vpnId, e);
 903         }
 904     }
 905
 906     public static void removeVpnExtraRouteForVpn(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
 907         try {
 908             // Clean up VPNExtraRoutes Operational DS
 909             if (writeTxn != null) {
 910                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
 911                         InstanceIdentifier.builder(VpnToExtraroute.class).child(Vpn.class, new VpnKey(vpnName)).build());
 912             } else {
 913                 delete(broker, LogicalDatastoreType.OPERATIONAL,
 914                         InstanceIdentifier.builder(VpnToExtraroute.class).child(Vpn.class, new VpnKey(vpnName)).build(),
 915                         DEFAULT_CALLBACK);
 916             }
 917         } catch (Exception e) {
 918             LOG.error("Exception during cleanup of VPNToExtraRoute for VPN {}", vpnName, e);
 919         }
 920     }
 921
 922     public static void removeVpnOpInstance(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
 923         try {
 924             // Clean up VPNInstanceOpDataEntry
 925             if (writeTxn != null) {
 926                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName));
 927             } else {
 928                 delete(broker, LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName),
 929                         DEFAULT_CALLBACK);
 930             }
 931         } catch (Exception e) {
 932             LOG.error("Exception during cleanup of VPNInstanceOpDataEntry for VPN {}", vpnName, e);
 933         }
 934     }
 935
 936     public static void removeVpnInstanceToVpnId(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
 937         try {
 938             if (writeTxn != null) {
 939                 writeTxn.delete(LogicalDatastoreType.CONFIGURATION, getVpnInstanceToVpnIdIdentifier(vpnName));
 940             } else {
 941                 delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnInstanceToVpnIdIdentifier(vpnName),
 942                         DEFAULT_CALLBACK);
 943             }
 944         } catch (Exception e) {
 945             LOG.error("Exception during clean up of VpnInstanceToVpnId for VPN {}", vpnName, e);
 946         }
 947     }
 948
 949     public static void removeVpnIdToVpnInstance(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
 950         try {
 951             if (writeTxn != null) {
 952                 writeTxn.delete(LogicalDatastoreType.CONFIGURATION, getVpnIdToVpnInstanceIdentifier(vpnId));
 953             } else {
 954                 delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnIdToVpnInstanceIdentifier(vpnId),
 955                         DEFAULT_CALLBACK);
 956             }
 957         } catch (Exception e) {
 958             LOG.error("Exception during clean up of VpnIdToVpnInstance for VPNID {}", vpnId, e);
 959         }
 960     }
 961
 962     public static void removeVrfTableForVpn(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
 963         // Clean up FIB Entries Config DS
 964         try {
 965             if (writeTxn != null) {
 966                 writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
 967                         InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(vpnName)).build());
 968             } else {
 969                 delete(broker, LogicalDatastoreType.CONFIGURATION,
 970                         InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(vpnName)).build(),
 971                         DEFAULT_CALLBACK);
 972             }
 973         } catch (Exception e) {
 974             LOG.error("Exception during clean up of VrfTable from FIB for VPN {}", vpnName, e);
 975         }
 976     }
 977
 978     public static void removeL3nexthopForVpnId(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
 979         try {
 980             // Clean up L3NextHop Operational DS
 981             if (writeTxn != null) {
 982                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
 983                         InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId)).build());
 984             } else {
 985                 delete(broker, LogicalDatastoreType.OPERATIONAL,
 986                         InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class, new VpnNexthopsKey(vpnId)).build(),
 987                         DEFAULT_CALLBACK);
 988             }
 989         } catch (Exception e) {
 990             LOG.error("Exception during cleanup of L3NextHop for VPN ID {}", vpnId, e);
 991         }
 992     }
 993
 994     /**
 995      * Retrieves the ids of the currently operative DPNs
 996      *
 997      * @param dataBroker dataBroker service reference
 998      * @return the list of DPNs currently operative
 999      */
1000     public static List<BigInteger> getOperativeDPNs(DataBroker dataBroker) {
1001         List<BigInteger> result = new LinkedList<BigInteger>();
1002         InstanceIdentifier<Nodes> nodesInstanceIdentifier = InstanceIdentifier.builder(Nodes.class).build();
1003         Optional<Nodes> nodesOptional = MDSALUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
1004                 nodesInstanceIdentifier);
1005         if (!nodesOptional.isPresent()) {
1006             return result;
1007         }
1008         Nodes nodes = nodesOptional.get();
1009         List<Node> nodeList = nodes.getNode();
1010         for (Node node : nodeList) {
1011             NodeId nodeId = node.getId();
1012             if (nodeId != null) {
1013                 BigInteger dpnId = MDSALUtil.getDpnIdFromNodeName(nodeId);
1014                 result.add(dpnId);
1015             }
1016         }
1017         return result;
1018     }
1019
1020     /**
1021      * Retrieves a list of randomly selected DPNs, as many as specified.
1022      *
1023      * @param dataBroker dataBroker service reference
1024      * @param numberOfDPNs Specifies how many Operative DPNs must be found
1025      * @param excludingDPNs Specifies a blacklist of DPNs
1026      * @return the list of DPN Ids
1027      */
1028     public static List<BigInteger> pickRandomDPNs(DataBroker dataBroker, int numberOfDPNs,
1029                                                   List<BigInteger> excludingDPNs) {
1030         List<BigInteger> dpnIdPool = getOperativeDPNs(dataBroker);
1031         int poolSize = dpnIdPool.size();
1032         if (poolSize <= numberOfDPNs) {
1033             // You requested more than there is, I give you all I have.
1034             return dpnIdPool;
1035         }
1036
1037         // Random reorder
1038         Collections.shuffle(dpnIdPool);
1039         List<BigInteger> result = new ArrayList<BigInteger>();
1040
1041         for (BigInteger dpId : dpnIdPool) {
1042             if (excludingDPNs == null || !excludingDPNs.contains(dpId)) {
1043                 result.add(dpId);
1044                 if (result.size() == numberOfDPNs)
1045                     break;
1046             }
1047         }
1048
1049         if (result.size() < numberOfDPNs) {
1050             // We still don't have all we need, so we have to pick up among the "prohibited" ones
1051             dpnIdPool.removeAll(result);
1052
1053             int nbrOfProhibitedDpnsToPick = numberOfDPNs - result.size();
1054             for (int i = 0; i < nbrOfProhibitedDpnsToPick; i++) {
1055                 result.add(dpnIdPool.get(i));
1056             }
1057         }
1058         return result;
1059     }
1060
1061     public static void scheduleVpnInterfaceForRemoval(DataBroker broker,String interfaceName, BigInteger dpnId,
1062                                                       String vpnInstanceName, Boolean isScheduledToRemove,
1063                                                       WriteTransaction writeOperTxn){
1064         InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
1065         VpnInterface interfaceToUpdate = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(interfaceName)).setName(interfaceName)
1066                 .setDpnId(dpnId).setVpnInstanceName(vpnInstanceName).setScheduledForRemove(isScheduledToRemove).build();
1067         if (writeOperTxn != null) {
1068             writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate, true);
1069         } else {
1070             VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate);
1071         }
1072     }
1073
1074     public static Port getNeutronPortForFloatingIp(DataBroker broker,
1075             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress targetIP) {
1076         InstanceIdentifier<Ports> portsIdentifier = InstanceIdentifier.create(Neutron.class).child(Ports.class);
1077         Optional<Ports> portsOptional = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, portsIdentifier);
1078         if (!portsOptional.isPresent() || portsOptional.get().getPort() == null) {
1079             LOG.trace("No neutron ports found");
1080             return null;
1081         }
1082
1083         for (Port port : portsOptional.get().getPort()) {
1084             if (NeutronConstants.DEVICE_OWNER_FLOATING_IP.equals(port.getDeviceOwner()) && port.getFixedIps() != null) {
1085                 for (FixedIps ip : port.getFixedIps()) {
1086                     if (Objects.equals(ip.getIpAddress(), targetIP)) {
1087                         return port;
1088                     }
1089                 }
1090             }
1091         }
1092
1093         return null;
1094     }
1095
1096     protected static void createVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp,
1097                                                      String portName, String macAddress, boolean isSubnetIp, boolean isConfig,
1098                                                      boolean isLearnt) {
1099         InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
1100         VpnPortipToPortBuilder builder = new VpnPortipToPortBuilder().setKey(
1101                 new VpnPortipToPortKey(fixedIp, vpnName)).setVpnName(vpnName).setPortFixedip(fixedIp).setPortName(portName)
1102                 .setMacAddress(macAddress.toLowerCase()).setSubnetIp(isSubnetIp).setConfig(isConfig).setLearnt(isLearnt);
1103         MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, builder.build());
1104         LOG.debug("ARP learned for fixedIp: {}, vpn {}, interface {}, mac {}, isSubnetIp {} added to VpnPortipToPort DS",
1105                 fixedIp, vpnName, portName, macAddress, isLearnt);
1106     }
1107
1108     protected static void updateVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp,
1109                                                      String portName, String macAddress, boolean isSubnetIp,boolean isConfig,
1110                                                      boolean isLearnt) {
1111         InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
1112         VpnPortipToPortBuilder builder = new VpnPortipToPortBuilder().setKey(
1113                 new VpnPortipToPortKey(fixedIp, vpnName)).setVpnName(vpnName).setPortFixedip(fixedIp).setPortName(portName)
1114                 .setMacAddress(macAddress.toLowerCase()).setSubnetIp(isSubnetIp).setConfig(isConfig).setLearnt(isLearnt);;
1115         MDSALUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, id, builder.build());
1116         LOG.debug("Updated Arp learnt fixedIp: {}, vpn {}, interface {}, mac {}, isLearnt {} Updated to VpnPortipToPort DS",
1117                 fixedIp, vpnName, portName, macAddress, isLearnt);
1118     }
1119
1120     protected static void removeVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp) {
1121         InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
1122         MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, id);
1123         LOG.debug("Delete learned ARP for fixedIp: {}, vpn {} removed from VpnPortipToPort DS",
1124                 fixedIp, vpnName);
1125     }
1126
1127     static InstanceIdentifier<VpnPortipToPort> buildVpnPortipToPortIdentifier(String vpnName, String fixedIp) {
1128         InstanceIdentifier<VpnPortipToPort> id = InstanceIdentifier.builder(NeutronVpnPortipPortData.class).child
1129                 (VpnPortipToPort.class, new VpnPortipToPortKey(fixedIp, vpnName)).build();
1130         return id;
1131     }
1132
1133     static VpnPortipToPort getNeutronPortFromVpnPortFixedIp(DataBroker broker, String vpnName, String fixedIp) {
1134         InstanceIdentifier id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
1135         Optional<VpnPortipToPort> vpnPortipToPortData = read(broker, LogicalDatastoreType.OPERATIONAL, id);
1136         if (vpnPortipToPortData.isPresent()) {
1137             return (vpnPortipToPortData.get());
1138         }
1139         return null;
1140     }
1141
1142     public static List<BigInteger> getDpnsOnVpn(DataBroker dataBroker, String vpnInstanceName) {
1143         List<BigInteger> result = new ArrayList<BigInteger>();
1144         String rd = getVpnRd(dataBroker, vpnInstanceName);
1145         if ( rd == null ) {
1146             LOG.debug("Could not find Route-Distinguisher for VpnName={}", vpnInstanceName);
1147             return result;
1148         }
1149
1150         VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(dataBroker, rd);
1151         if ( vpnInstanceOpData == null ) {
1152             LOG.debug("Could not find OpState for VpnName={}", vpnInstanceName);
1153             return result;
1154         }
1155
1156         List<VpnToDpnList> vpnToDpnList = vpnInstanceOpData.getVpnToDpnList();
1157         if ( vpnToDpnList == null ) {
1158             LOG.debug("Could not find DPN footprint for VpnName={}", vpnInstanceName);
1159             return result;
1160         }
1161         for ( VpnToDpnList vpnToDpn : vpnToDpnList) {
1162             result.add(vpnToDpn.getDpnId());
1163         }
1164         return result;
1165     }
1166
1167     static String getAssociatedExternalNetwork(DataBroker dataBroker, String routerId) {
1168         InstanceIdentifier<Routers> id = buildRouterIdentifier(routerId);
1169         Optional<Routers> routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
1170         if (routerData.isPresent()) {
1171             Uuid networkId = routerData.get().getNetworkId();
1172             if(networkId != null) {
1173                 return networkId.getValue();
1174             }
1175         }
1176         return null;
1177     }
1178
1179     static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
1180         InstanceIdentifier<Routers> routerInstanceIndentifier = InstanceIdentifier.builder(ExtRouters.class).child
1181                 (Routers.class, new RoutersKey(routerId)).build();
1182         return routerInstanceIndentifier;
1183     }
1184 }