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