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

   1 /*
   2  * Copyright © 2016, 2017 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 com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.CheckedFuture;
  13 import com.google.common.util.concurrent.FutureCallback;
  14 import com.google.common.util.concurrent.Futures;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16
  17 import java.math.BigInteger;
  18 import java.util.ArrayList;
  19 import java.util.Collections;
  20 import java.util.List;
  21 import java.util.concurrent.ExecutionException;
  22 import java.util.concurrent.Future;
  23 import java.util.stream.Collectors;
  24
  25 import org.apache.commons.lang3.tuple.ImmutablePair;
  26 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  27 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  28 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  29 import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipService;
  30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  31 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  32 import org.opendaylight.genius.datastoreutils.DataStoreJobCoordinator;
  33 import org.opendaylight.genius.mdsalutil.FlowEntity;
  34 import org.opendaylight.genius.mdsalutil.InstructionInfo;
  35 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  36 import org.opendaylight.genius.mdsalutil.MatchInfo;
  37 import org.opendaylight.genius.mdsalutil.MetaDataUtil;
  38 import org.opendaylight.genius.mdsalutil.NwConstants;
  39 import org.opendaylight.genius.mdsalutil.actions.ActionRegLoad;
  40 import org.opendaylight.genius.mdsalutil.instructions.InstructionGotoTable;
  41 import org.opendaylight.genius.mdsalutil.instructions.InstructionWriteMetadata;
  42 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  43 import org.opendaylight.genius.mdsalutil.matches.MatchEthernetDestination;
  44 import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
  45 import org.opendaylight.genius.utils.ServiceIndex;
  46 import org.opendaylight.genius.utils.cache.DataStoreCache;
  47 import org.opendaylight.genius.utils.clustering.ClusteringUtils;
  48 import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
  49 import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
  50 import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
  51 import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
  52 import org.opendaylight.netvirt.vpnmanager.utilities.InterfaceUtils;
  53 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
  54 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  55 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  56 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  57 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  58 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  59 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  61 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  62 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  63 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  64 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  65 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  66 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
  67 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInput;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInputBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutput;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TimeUnits;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInput;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInputBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInputBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanTagNameMap;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagName;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagNameKey;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.ExtrarouteRdsMap;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.ExtrarouteRds;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.ExtrarouteRdsKey;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.DestPrefixes;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.DestPrefixesBuilder;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.DestPrefixesKey;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.L3nexthop;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthops;
 109 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
 110 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
 111 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
 112 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
 113 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PrefixToInterface;
 114 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RouterInterfaces;
 115 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
 116 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnIdToVpnInstance;
 117 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
 118 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId;
 119 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnToExtraroutes;
 120 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
 121 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
 122 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortBuilder;
 123 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortKey;
 124 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIds;
 125 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsBuilder;
 126 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsKey;
 127 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
 128 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
 129 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesKey;
 130 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
 131 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceBuilder;
 132 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceKey;
 133 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntry;
 134 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
 135 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
 136 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
 137 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
 138 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
 139 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder;
 140 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.Vpn;
 141 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.VpnKey;
 142 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
 143 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.RoutesBuilder;
 144 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
 145 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
 146 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalSubnets;
 147 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches;
 148 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
 149 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
 150 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
 151 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
 152 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
 153 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.SubnetsKey;
 154 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
 155 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchKey;
 156 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
 157 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortipPortData;
 158 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap;
 159 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
 160 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
 161 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
 162 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
 163 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortKey;
 164 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
 165 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
 166 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionBase;
 167 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionV4;
 168 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
 169 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
 170 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
 171 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
 172 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
 173 import org.opendaylight.yangtools.yang.binding.DataObject;
 174 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 175 import org.opendaylight.yangtools.yang.common.RpcResult;
 176 import org.opendaylight.yangtools.yang.data.impl.schema.tree.SchemaValidationFailedException;
 177 import org.slf4j.Logger;
 178 import org.slf4j.LoggerFactory;
 179
 180 public class VpnUtil {
 181     private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
 182     private static final int DEFAULT_PREFIX_LENGTH = 32;
 183     private static final String PREFIX_SEPARATOR = "/";
 184
 185     static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
 186         return InstanceIdentifier.builder(VpnInterfaces.class)
 187             .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
 188     }
 189
 190     static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
 191         return InstanceIdentifier.builder(VpnInstances.class)
 192             .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 193     }
 194
 195     static VpnInterface getVpnInterface(DataBroker broker, String vpnInterfaceName) {
 196         InstanceIdentifier<VpnInterface> id = getVpnInterfaceIdentifier(vpnInterfaceName);
 197         Optional<VpnInterface> vpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 198         return (vpnInterface.isPresent()) ? vpnInterface.get() : null;
 199     }
 200
 201     static VpnInterface getVpnInterface(String intfName, String vpnName, Adjacencies aug, BigInteger dpnId,
 202         Boolean isSheduledForRemove) {
 203         return new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(intfName)).setVpnInstanceName(vpnName).setDpnId(
 204             dpnId)
 205             .setScheduledForRemove(isSheduledForRemove).addAugmentation(Adjacencies.class, aug)
 206             .build();
 207     }
 208
 209     static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(long vpnId, String ipPrefix) {
 210         return InstanceIdentifier.builder(PrefixToInterface.class)
 211             .child(VpnIds.class, new VpnIdsKey(vpnId)).child(Prefixes.class,
 212                 new PrefixesKey(ipPrefix)).build();
 213     }
 214
 215     static InstanceIdentifier<VpnIds> getPrefixToInterfaceIdentifier(long vpnId) {
 216         return InstanceIdentifier.builder(PrefixToInterface.class)
 217             .child(VpnIds.class, new VpnIdsKey(vpnId)).build();
 218     }
 219
 220     static VpnIds getPrefixToInterface(long vpnId) {
 221         return new VpnIdsBuilder().setKey(new VpnIdsKey(vpnId)).setVpnId(vpnId).build();
 222     }
 223
 224     static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix, Uuid subnetId,
 225             boolean isNatPrefix) {
 226         return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
 227             vpnInterfaceName).setIpAddress(ipPrefix).setSubnetId(subnetId).setNatPrefix(isNatPrefix).build();
 228     }
 229
 230     static Optional<Prefixes> getPrefixToInterface(DataBroker broker, long vpnId, String ipPrefix) {
 231         return read(broker, LogicalDatastoreType.OPERATIONAL,
 232                 getPrefixToInterfaceIdentifier(vpnId, getIpPrefix(ipPrefix)));
 233     }
 234
 235     /**
 236      * Get VRF table given a Route Distinguisher.
 237      *
 238      * @param broker dataBroker service reference
 239      * @param rd Route-Distinguisher
 240      * @return VrfTables that holds the list of VrfEntries of the specified rd
 241      */
 242     public static VrfTables getVrfTable(DataBroker broker, String rd) {
 243         InstanceIdentifier<VrfTables> id =
 244             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 245         Optional<VrfTables> vrfTable = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 246         return vrfTable.isPresent() ? vrfTable.get() : null;
 247     }
 248
 249     /**
 250      * Retrieves the VrfEntries that belong to a given VPN filtered out by
 251      * Origin, searching by its Route-Distinguisher.
 252      *
 253      * @param broker dataBroker service reference
 254      * @param rd Route-distinguisher of the VPN
 255      * @param originsToConsider Only entries whose origin is included in this list will be considered
 256      * @return the list of VrfEntries
 257      */
 258     public static List<VrfEntry> getVrfEntriesByOrigin(DataBroker broker, String rd,
 259         List<RouteOrigin> originsToConsider) {
 260         List<VrfEntry> result = new ArrayList<>();
 261         List<VrfEntry> allVpnVrfEntries = getAllVrfEntries(broker, rd);
 262         for (VrfEntry vrfEntry : allVpnVrfEntries) {
 263             if (originsToConsider.contains(RouteOrigin.value(vrfEntry.getOrigin()))) {
 264                 result.add(vrfEntry);
 265             }
 266         }
 267         return result;
 268     }
 269
 270     static List<Prefixes> getAllPrefixesToInterface(DataBroker broker, long vpnId) {
 271         Optional<VpnIds> vpnIds = read(broker, LogicalDatastoreType.OPERATIONAL, getPrefixToInterfaceIdentifier(vpnId));
 272         if (vpnIds.isPresent()) {
 273             return vpnIds.get().getPrefixes();
 274         }
 275         return new ArrayList<>();
 276     }
 277
 278     /**
 279      * Retrieves all the VrfEntries that belong to a given VPN searching by its
 280      * Route-Distinguisher.
 281      *
 282      * @param broker dataBroker service reference
 283      * @param rd Route-distinguisher of the VPN
 284      * @return the list of VrfEntries
 285      */
 286     public static List<VrfEntry> getAllVrfEntries(DataBroker broker, String rd) {
 287         VrfTables vrfTables = VpnUtil.getVrfTable(broker, rd);
 288         return (vrfTables != null) ? vrfTables.getVrfEntry() : new ArrayList<>();
 289     }
 290
 291     //FIXME: Implement caches for DS reads
 292     public static VpnInstance getVpnInstance(DataBroker broker, String vpnInstanceName) {
 293         InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,
 294             new VpnInstanceKey(vpnInstanceName)).build();
 295         Optional<VpnInstance> vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 296         return (vpnInstance.isPresent()) ? vpnInstance.get() : null;
 297     }
 298
 299     static List<VpnInstance> getAllVpnInstances(DataBroker broker) {
 300         InstanceIdentifier<VpnInstances> id = InstanceIdentifier.builder(VpnInstances.class).build();
 301         Optional<VpnInstances> optVpnInstances = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 302         if (optVpnInstances.isPresent()) {
 303             return optVpnInstances.get().getVpnInstance();
 304         } else {
 305             return Collections.emptyList();
 306         }
 307     }
 308
 309     static List<VpnInstanceOpDataEntry> getAllVpnInstanceOpData(DataBroker broker) {
 310         InstanceIdentifier<VpnInstanceOpData> id = InstanceIdentifier.builder(VpnInstanceOpData.class).build();
 311         Optional<VpnInstanceOpData> vpnInstanceOpDataOptional =
 312             VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
 313         if (vpnInstanceOpDataOptional.isPresent()) {
 314             return vpnInstanceOpDataOptional.get().getVpnInstanceOpDataEntry();
 315         } else {
 316             return new ArrayList<>();
 317         }
 318     }
 319
 320     public static List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn
 321         .instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> getDpnVpnInterfaces(DataBroker broker,
 322         VpnInstance vpnInstance, BigInteger dpnId) {
 323         String primaryRd = getPrimaryRd(vpnInstance);
 324         InstanceIdentifier<VpnToDpnList> dpnToVpnId = getVpnToDpnListIdentifier(primaryRd, dpnId);
 325         Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
 326         return dpnInVpn.isPresent() ? dpnInVpn.get().getVpnInterfaces() : Collections.emptyList();
 327     }
 328
 329     public static List<String> getListOfRdsFromVpnInstance(VpnInstance vpnInstance) {
 330         VpnAfConfig vpnConfig = vpnInstance.getIpv4Family();
 331         LOG.trace("vpnConfig {}", vpnConfig);
 332         return vpnConfig.getRouteDistinguisher() != null ? new ArrayList<>(
 333                 vpnConfig.getRouteDistinguisher()) : new ArrayList<>();
 334     }
 335
 336     static VrfEntry getVrfEntry(DataBroker broker, String rd, String ipPrefix) {
 337
 338         VrfTables vrfTable = getVrfTable(broker, rd);
 339         // TODO: why check VrfTables if we later go for the specific VrfEntry?
 340         if (vrfTable != null) {
 341             InstanceIdentifier<VrfEntry> vrfEntryId =
 342                 InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
 343                     VrfEntry.class, new VrfEntryKey(ipPrefix)).build();
 344             Optional<VrfEntry> vrfEntry = read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
 345             if (vrfEntry.isPresent()) {
 346                 return vrfEntry.get();
 347             }
 348         }
 349         return null;
 350     }
 351
 352     static List<Adjacency> getAdjacenciesForVpnInterfaceFromConfig(DataBroker broker, String intfName) {
 353         final InstanceIdentifier<VpnInterface> identifier = getVpnInterfaceIdentifier(intfName);
 354         InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
 355         Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
 356
 357         if (adjacencies.isPresent()) {
 358             List<Adjacency> nextHops = adjacencies.get().getAdjacency();
 359             return nextHops;
 360         }
 361         return null;
 362     }
 363
 364     static  Routes getVpnToExtraroute(String ipPrefix, List<String> nextHopList) {
 365         return new RoutesBuilder().setPrefix(ipPrefix).setNexthopIpList(nextHopList).build();
 366     }
 367
 368     static String getVpnInterfaceName(OdlInterfaceRpcService odlInterfaceRpcService, BigInteger metadata)
 369             throws InterruptedException, ExecutionException {
 370         GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
 371         BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata);
 372         ifIndexInputBuilder.setIfIndex(lportTag.intValue());
 373         GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
 374         Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex =
 375                 odlInterfaceRpcService.getInterfaceFromIfIndex(input);
 376         GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput;
 377         RpcResult<GetInterfaceFromIfIndexOutput> rpcResult = interfaceFromIfIndex.get();
 378         if (rpcResult == null) {
 379             return null;
 380         }
 381
 382         interfaceFromIfIndexOutput = rpcResult.getResult();
 383         String interfaceName = interfaceFromIfIndexOutput.getInterfaceName();
 384         return interfaceName;
 385     }
 386
 387     static  List<String> getUsedRds(DataBroker broker, long vpnId, String destPrefix) {
 388         InstanceIdentifier<DestPrefixes> usedRdsId = getUsedRdsIdentifier(vpnId, destPrefix);
 389         Optional<DestPrefixes> usedRds = read(broker, LogicalDatastoreType.CONFIGURATION, usedRdsId);
 390         return usedRds.isPresent() ? usedRds.get().getRds() : new ArrayList<>();
 391     }
 392
 393     static  InstanceIdentifier<DestPrefixes> getUsedRdsIdentifier(long vpnId, String destPrefix) {
 394         return InstanceIdentifier.builder(ExtrarouteRdsMap.class)
 395                 .child(ExtrarouteRds.class, new ExtrarouteRdsKey(vpnId))
 396                 .child(DestPrefixes.class, new DestPrefixesKey(destPrefix)).build();
 397     }
 398
 399     static DestPrefixesBuilder getDestPrefixesBuilder(String destPrefix, List<String> rd) {
 400         return new DestPrefixesBuilder().setKey(new DestPrefixesKey(destPrefix))
 401                 .setDestPrefix(destPrefix).setRds(rd);
 402     }
 403
 404     static Adjacencies getVpnInterfaceAugmentation(List<Adjacency> nextHopList) {
 405         return new AdjacenciesBuilder().setAdjacency(nextHopList).build();
 406     }
 407
 408     public static InstanceIdentifier<IdPool> getPoolId(String poolName) {
 409         InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
 410             InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
 411         InstanceIdentifier<IdPool> id = idBuilder.build();
 412         return id;
 413     }
 414
 415     static InstanceIdentifier<VpnInterfaces> getVpnInterfacesIdentifier() {
 416         return InstanceIdentifier.builder(VpnInterfaces.class).build();
 417     }
 418
 419     static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
 420         return InstanceIdentifier.builder(Interfaces.class)
 421             .child(Interface.class, new InterfaceKey(interfaceName)).build();
 422     }
 423
 424     static InstanceIdentifier<VpnToDpnList> getVpnToDpnListIdentifier(String rd, BigInteger dpnId) {
 425         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 426             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd))
 427             .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId)).build();
 428     }
 429
 430     public static BigInteger getCookieArpFlow(int interfaceTag) {
 431         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0110000", 16)).add(
 432             BigInteger.valueOf(interfaceTag));
 433     }
 434
 435     public static BigInteger getCookieL3(int vpnId) {
 436         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0610000", 16)).add(BigInteger.valueOf(vpnId));
 437     }
 438
 439     public static String getFlowRef(BigInteger dpnId, short tableId, int ethType, int lportTag, int arpType) {
 440         return new StringBuffer().append(VpnConstants.FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
 441             .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(ethType).append(lportTag)
 442             .append(NwConstants.FLOWID_SEPARATOR).append(arpType).toString();
 443     }
 444
 445     public static int getUniqueId(IdManagerService idManager, String poolName, String idKey) {
 446         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 447
 448         try {
 449             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 450             RpcResult<AllocateIdOutput> rpcResult = result.get();
 451             if (rpcResult.isSuccessful()) {
 452                 return rpcResult.getResult().getIdValue().intValue();
 453             } else {
 454                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 455             }
 456         } catch (InterruptedException | ExecutionException e) {
 457             LOG.warn("Exception when getting Unique Id", e);
 458         }
 459         return 0;
 460     }
 461
 462     public static void releaseId(IdManagerService idManager, String poolName, String idKey) {
 463         ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 464         try {
 465             Future<RpcResult<Void>> result = idManager.releaseId(idInput);
 466             RpcResult<Void> rpcResult = result.get();
 467             if (!rpcResult.isSuccessful()) {
 468                 LOG.warn("RPC Call to Get Unique Id returned with Errors {}", rpcResult.getErrors());
 469             }
 470         } catch (InterruptedException | ExecutionException e) {
 471             LOG.warn("Exception when getting Unique Id for key {}", idKey, e);
 472         }
 473     }
 474
 475     public static String getNextHopLabelKey(String rd, String prefix) {
 476         return rd + VpnConstants.SEPARATOR + prefix;
 477     }
 478
 479     /**
 480      * Retrieves the VpnInstance name (typically the VPN Uuid) out from the
 481      * route-distinguisher.
 482      *
 483      * @param broker dataBroker service reference
 484      * @param rd Route-Distinguisher
 485      * @return the VpnInstance name
 486      */
 487     public static String getVpnNameFromRd(DataBroker broker, String rd) {
 488         VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(broker, rd);
 489         return (vpnInstanceOpData != null) ? vpnInstanceOpData.getVpnInstanceName() : null;
 490     }
 491
 492     /**
 493      * Retrieves the dataplane identifier of a specific VPN, searching by its
 494      * VpnInstance name.
 495      *
 496      * @param broker dataBroker service reference
 497      * @param vpnName Name of the VPN
 498      * @return the dataplane identifier of the VPN, the VrfTag.
 499      */
 500     public static long getVpnId(DataBroker broker, String vpnName) {
 501         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn
 502             .id.VpnInstance>
 503             id
 504             = getVpnInstanceToVpnIdIdentifier(vpnName);
 505         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
 506             .VpnInstance>
 507             vpnInstance
 508             = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 509         long vpnId = VpnConstants.INVALID_ID;
 510         if (vpnInstance.isPresent()) {
 511             vpnId = vpnInstance.get().getVpnId();
 512         }
 513         return vpnId;
 514     }
 515
 516     /**
 517      * Retrieves the VPN Route Distinguisher searching by its Vpn instance name.
 518      *
 519      * @param broker dataBroker service reference
 520      * @param vpnName Name of the VPN
 521      * @return the route-distinguisher of the VPN
 522      */
 523     public static String getVpnRd(DataBroker broker, String vpnName) {
 524         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn
 525             .id.VpnInstance>
 526             id
 527             = getVpnInstanceToVpnIdIdentifier(vpnName);
 528         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
 529             .VpnInstance>
 530             vpnInstance
 531             = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 532
 533         String rd = null;
 534         if (vpnInstance.isPresent()) {
 535             rd = vpnInstance.get().getVrfId();
 536         }
 537         return rd;
 538     }
 539
 540     private static List<String> getVpnRdsFromVpnInstanceConfig(DataBroker broker, String vpnName) {
 541         InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
 542             .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 543         Optional<VpnInstance> vpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 544         return vpnInstance.isPresent() ? getListOfRdsFromVpnInstance(vpnInstance.get()) : new ArrayList<>();
 545     }
 546
 547     /**
 548      * Remove from MDSAL all those VrfEntries in a VPN that have an specific RouteOrigin.
 549      *
 550      * @param broker dataBroker service reference
 551      * @param rd Route Distinguisher
 552      * @param origin Origin of the Routes to be removed (see {@link RouteOrigin})
 553      */
 554     public static void removeVrfEntriesByOrigin(DataBroker broker, String rd, RouteOrigin origin) {
 555         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 556             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 557         Optional<VrfTables> vrfTablesOpc = read(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
 558         if (vrfTablesOpc.isPresent()) {
 559             VrfTables vrfTables = vrfTablesOpc.get();
 560             WriteTransaction tx = broker.newWriteOnlyTransaction();
 561             for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
 562                 if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
 563                     tx.delete(LogicalDatastoreType.CONFIGURATION,
 564                             vpnVrfTableIid.child(VrfEntry.class, vrfEntry.getKey()));
 565                 }
 566             }
 567             tx.submit();
 568         }
 569     }
 570
 571     public static List<VrfEntry> findVrfEntriesByNexthop(DataBroker broker, String rd, String nexthop) {
 572         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 573             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 574         Optional<VrfTables> vrfTablesOpc = read(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
 575         List<VrfEntry> matches = new ArrayList<>();
 576
 577         if (vrfTablesOpc.isPresent()) {
 578             VrfTables vrfTables = vrfTablesOpc.get();
 579             for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
 580                 vrfEntry.getRoutePaths().stream()
 581                         .filter(routePath -> routePath.getNexthopAddress() != null
 582                                 && routePath.getNexthopAddress().equals(nexthop))
 583                         .findFirst().ifPresent(routePath -> matches.add(vrfEntry));
 584             }
 585         }
 586         return matches;
 587     }
 588
 589     public static void removeVrfEntries(DataBroker broker, String rd, List<VrfEntry> vrfEntries) {
 590         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 591             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 592         WriteTransaction tx = broker.newWriteOnlyTransaction();
 593         for (VrfEntry vrfEntry : vrfEntries) {
 594             tx.delete(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid.child(VrfEntry.class, vrfEntry.getKey()));
 595         }
 596         tx.submit();
 597     }
 598
 599     // TODO Clean up the exception handling
 600     @SuppressWarnings("checkstyle:IllegalCatch")
 601     public static void withdrawRoutes(IBgpManager bgpManager, String rd, List<VrfEntry> vrfEntries) {
 602         vrfEntries.forEach(vrfEntry -> {
 603             try {
 604                 bgpManager.withdrawPrefix(rd, vrfEntry.getDestPrefix());
 605             } catch (Exception e) {
 606                 LOG.error("Could not withdraw route to {} with route-paths {} in VpnRd {}",
 607                           vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths(), rd);
 608             }
 609         });
 610     }
 611
 612     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
 613         getVpnInstanceToVpnId(String vpnName, long vpnId, String rd) {
 614         return new VpnInstanceBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
 615
 616     }
 617
 618     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to
 619         .vpn.id.VpnInstance>
 620         getVpnInstanceToVpnIdIdentifier(String vpnName) {
 621         return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
 622             .child(
 623                 org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
 624                     .VpnInstance.class,
 625                 new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
 626                     .VpnInstanceKey(
 627                     vpnName)).build();
 628     }
 629
 630     static RouterInterface getConfiguredRouterInterface(DataBroker broker, String interfaceName) {
 631         Optional<RouterInterface> optRouterInterface =
 632             read(broker, LogicalDatastoreType.CONFIGURATION, VpnUtil.getRouterInterfaceId(interfaceName));
 633         if (optRouterInterface.isPresent()) {
 634             return optRouterInterface.get();
 635         }
 636         return null;
 637     }
 638
 639     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
 640         getVpnIdToVpnInstance(long vpnId, String vpnName, String rd, boolean isExternalVpn) {
 641         return new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
 642             .VpnIdsBuilder()
 643             .setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).setExternalVpn(isExternalVpn).build();
 644
 645     }
 646
 647     public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to
 648         .vpn.instance.VpnIds>
 649         getVpnIdToVpnInstanceIdentifier(long vpnId) {
 650         return InstanceIdentifier.builder(VpnIdToVpnInstance.class)
 651             .child(
 652                 org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
 653                     .class,
 654                 new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
 655                     .VpnIdsKey(vpnId)).build();
 656     }
 657
 658     /**
 659      * Retrieves the Vpn Name searching by its VPN Tag.
 660      *
 661      * @param broker dataBroker service reference
 662      * @param vpnId Dataplane identifier of the VPN
 663      * @return the Vpn instance name
 664      */
 665     public static String getVpnName(DataBroker broker, long vpnId) {
 666
 667         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
 668             .instance.VpnIds>
 669             id
 670             = getVpnIdToVpnInstanceIdentifier(vpnId);
 671         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
 672             vpnInstance
 673             = read(broker, LogicalDatastoreType.CONFIGURATION, id);
 674
 675         String vpnName = null;
 676         if (vpnInstance.isPresent()) {
 677             vpnName = vpnInstance.get().getVpnInstanceName();
 678         }
 679         return vpnName;
 680     }
 681
 682     public static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 683         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 684             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 685     }
 686
 687     static InstanceIdentifier<RouterInterface> getRouterInterfaceId(String interfaceName) {
 688         return InstanceIdentifier.builder(RouterInterfaces.class)
 689             .child(RouterInterface.class, new RouterInterfaceKey(interfaceName)).build();
 690     }
 691
 692     static RouterInterface getRouterInterface(String interfaceName, String routerName) {
 693         return new RouterInterfaceBuilder().setKey(new RouterInterfaceKey(interfaceName))
 694             .setInterfaceName(interfaceName).setRouterName(routerName).build();
 695     }
 696
 697     public static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
 698         InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
 699         return read(broker, LogicalDatastoreType.OPERATIONAL, id).orNull();
 700     }
 701
 702     static VpnInstanceOpDataEntry getVpnInstanceOpDataFromCache(DataBroker broker, String rd) {
 703         InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
 704         return (VpnInstanceOpDataEntry) DataStoreCache.get(VpnConstants.VPN_OP_INSTANCE_CACHE_NAME, id, rd, broker,
 705             false);
 706     }
 707
 708     static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
 709         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 710         Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 711
 712         if (configuredVpnInterface.isPresent()) {
 713             return configuredVpnInterface.get();
 714         }
 715         return null;
 716     }
 717
 718     static String getNeutronRouterFromInterface(DataBroker broker, String interfaceName) {
 719         InstanceIdentifier.InstanceIdentifierBuilder<RouterInterfacesMap> idBuilder =
 720             InstanceIdentifier.builder(RouterInterfacesMap.class);
 721         InstanceIdentifier<RouterInterfacesMap> id = idBuilder.build();
 722         Optional<RouterInterfacesMap> routerInterfacesMap =
 723             MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
 724         if (routerInterfacesMap.isPresent()) {
 725             List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
 726                 .RouterInterfaces>
 727                 rtrInterfaces = routerInterfacesMap.get().getRouterInterfaces();
 728             for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
 729                      .RouterInterfaces rtrInterface : rtrInterfaces) {
 730                 List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
 731                     .router.interfaces.Interfaces>
 732                     rtrIfc = rtrInterface.getInterfaces();
 733                 for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
 734                          .router.interfaces.Interfaces ifc : rtrIfc) {
 735                     if (ifc.getInterfaceId().equals(interfaceName)) {
 736                         return rtrInterface.getRouterId().getValue();
 737                     }
 738                 }
 739             }
 740         }
 741         return null;
 742     }
 743
 744     static VpnInterface getOperationalVpnInterface(DataBroker broker, String interfaceName) {
 745         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 746         Optional<VpnInterface> operationalVpnInterface = read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
 747
 748         if (operationalVpnInterface.isPresent()) {
 749             return operationalVpnInterface.get();
 750         }
 751         return null;
 752     }
 753
 754     static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName) {
 755         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 756         return read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent();
 757     }
 758
 759     static boolean isInterfaceAssociatedWithVpn(DataBroker broker, String vpnName, String interfaceName) {
 760         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 761         Optional<VpnInterface> optConfiguredVpnInterface =
 762             read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
 763
 764         if (optConfiguredVpnInterface.isPresent()) {
 765             String configuredVpnName = optConfiguredVpnInterface.get().getVpnInstanceName();
 766             if ((configuredVpnName != null) && (configuredVpnName.equalsIgnoreCase(vpnName))) {
 767                 return true;
 768             }
 769         }
 770         return false;
 771     }
 772
 773     public static String getIpPrefix(String prefix) {
 774         String[] prefixValues = prefix.split("/");
 775         if (prefixValues.length == 1) {
 776             prefix = prefix + PREFIX_SEPARATOR + DEFAULT_PREFIX_LENGTH;
 777         }
 778         return prefix;
 779     }
 780
 781     static final FutureCallback<Void> DEFAULT_CALLBACK =
 782         new FutureCallback<Void>() {
 783             @Override
 784             public void onSuccess(Void result) {
 785                 LOG.debug("Success in Datastore operation");
 786             }
 787
 788             @Override
 789             public void onFailure(Throwable error) {
 790                 LOG.error("Error in Datastore operation", error);
 791             }
 792
 793             ;
 794         };
 795
 796     public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
 797                                                           InstanceIdentifier<T> path) {
 798         try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
 799             return tx.read(datastoreType, path).get();
 800         } catch (InterruptedException | ExecutionException e) {
 801             throw new RuntimeException(e);
 802         }
 803     }
 804
 805     public static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 806         InstanceIdentifier<T> path, T data) {
 807         asyncUpdate(broker, datastoreType, path, data, DEFAULT_CALLBACK);
 808     }
 809
 810     public static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 811         InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 812         WriteTransaction tx = broker.newWriteOnlyTransaction();
 813         tx.merge(datastoreType, path, data, true);
 814         Futures.addCallback(tx.submit(), callback);
 815     }
 816
 817     public static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 818         InstanceIdentifier<T> path, T data) {
 819         asyncWrite(broker, datastoreType, path, data, DEFAULT_CALLBACK);
 820     }
 821
 822     public static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 823         InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
 824         WriteTransaction tx = broker.newWriteOnlyTransaction();
 825         tx.put(datastoreType, path, data, true);
 826         Futures.addCallback(tx.submit(), callback);
 827     }
 828
 829     // TODO Clean up the exception handling
 830     @SuppressWarnings("checkstyle:IllegalCatch")
 831     public static <T extends DataObject> void tryDelete(DataBroker broker, LogicalDatastoreType datastoreType,
 832         InstanceIdentifier<T> path) {
 833         try {
 834             delete(broker, datastoreType, path, DEFAULT_CALLBACK);
 835         } catch (SchemaValidationFailedException sve) {
 836             LOG.info("Could not delete {}. SchemaValidationFailedException: {}", path, sve.getMessage());
 837         } catch (Exception e) {
 838             LOG.info("Could not delete {}. Unhandled error: {}", path, e.getMessage());
 839         }
 840     }
 841
 842     public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
 843         InstanceIdentifier<T> path) {
 844         delete(broker, datastoreType, path, DEFAULT_CALLBACK);
 845     }
 846
 847
 848     public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
 849         InstanceIdentifier<T> path, FutureCallback<Void> callback) {
 850         WriteTransaction tx = broker.newWriteOnlyTransaction();
 851         tx.delete(datastoreType, path);
 852         Futures.addCallback(tx.submit(), callback);
 853     }
 854
 855     public static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
 856         InstanceIdentifier<T> path, T data) {
 857         WriteTransaction tx = broker.newWriteOnlyTransaction();
 858         tx.put(datastoreType, path, data, true);
 859         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 860         try {
 861             futures.get();
 862         } catch (InterruptedException | ExecutionException e) {
 863             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 864             throw new RuntimeException(e.getMessage());
 865         }
 866     }
 867
 868     public static <T extends DataObject> void syncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
 869         InstanceIdentifier<T> path, T data) {
 870         WriteTransaction tx = broker.newWriteOnlyTransaction();
 871         tx.merge(datastoreType, path, data, true);
 872         CheckedFuture<Void, TransactionCommitFailedException> futures = tx.submit();
 873         try {
 874             futures.get();
 875         } catch (InterruptedException | ExecutionException e) {
 876             LOG.error("Error writing to datastore (path, data) : ({}, {})", path, data);
 877             throw new RuntimeException(e.getMessage());
 878         }
 879     }
 880
 881     public static long getRemoteBCGroup(long elanTag) {
 882         return VpnConstants.ELAN_GID_MIN + ((elanTag % VpnConstants.ELAN_GID_MIN) * 2);
 883     }
 884
 885     // interface-index-tag operational container
 886     public static IfIndexInterface getInterfaceInfoByInterfaceTag(DataBroker broker, long interfaceTag) {
 887         InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
 888         Optional<IfIndexInterface> existingInterfaceInfo =
 889             VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
 890         if (existingInterfaceInfo.isPresent()) {
 891             return existingInterfaceInfo.get();
 892         }
 893         return null;
 894     }
 895
 896     private static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
 897         return InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class,
 898             new IfIndexInterfaceKey((int) interfaceTag)).build();
 899     }
 900
 901     public static ElanTagName getElanInfoByElanTag(DataBroker broker, long elanTag) {
 902         InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
 903         Optional<ElanTagName> existingElanInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanId);
 904         if (existingElanInfo.isPresent()) {
 905             return existingElanInfo.get();
 906         }
 907         return null;
 908     }
 909
 910     private static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
 911         return InstanceIdentifier.builder(ElanTagNameMap.class).child(ElanTagName.class,
 912             new ElanTagNameKey(elanTag)).build();
 913     }
 914
 915     /**
 916      * Returns the Path identifier to reach a specific interface in a specific DPN in a given VpnInstance.
 917      *
 918      * @param vpnRd Route-Distinguisher of the VpnInstance
 919      * @param dpnId Id of the DPN where the interface is
 920      * @param ifaceName Interface name
 921      * @return the Instance Identifier
 922      */
 923     public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 924         .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces>
 925         getVpnToDpnInterfacePath(String vpnRd, BigInteger dpnId, String ifaceName) {
 926
 927         return
 928             InstanceIdentifier.builder(VpnInstanceOpData.class)
 929                 .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(vpnRd))
 930                 .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId))
 931                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 932                         .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
 933                     new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
 934                         .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfacesKey(ifaceName))
 935                 .build();
 936     }
 937
 938     // TODO Clean up the exception handling
 939     @SuppressWarnings("checkstyle:IllegalCatch")
 940     public static void removePrefixToInterfaceForVpnId(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
 941         try {
 942             // Clean up PrefixToInterface Operational DS
 943             if (writeTxn != null) {
 944                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
 945                     InstanceIdentifier.builder(PrefixToInterface.class).child(
 946                         VpnIds.class, new VpnIdsKey(vpnId)).build());
 947             } else {
 948                 delete(broker, LogicalDatastoreType.OPERATIONAL,
 949                     InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class,
 950                         new VpnIdsKey(vpnId)).build(),
 951                     DEFAULT_CALLBACK);
 952             }
 953         } catch (Exception e) {
 954             LOG.error("Exception during cleanup of PrefixToInterface for VPN ID {}", vpnId, e);
 955         }
 956     }
 957
 958     // TODO Clean up the exception handling
 959     @SuppressWarnings("checkstyle:IllegalCatch")
 960     public static void removeVpnExtraRouteForVpn(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
 961         try {
 962             // Clean up VPNExtraRoutes Operational DS
 963             if (writeTxn != null) {
 964                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
 965                         InstanceIdentifier.builder(VpnToExtraroutes.class)
 966                                 .child(Vpn.class, new VpnKey(vpnName)).build());
 967             } else {
 968                 delete(broker, LogicalDatastoreType.OPERATIONAL,
 969                         InstanceIdentifier.builder(VpnToExtraroutes.class)
 970                                 .child(Vpn.class, new VpnKey(vpnName)).build(),
 971                         DEFAULT_CALLBACK);
 972             }
 973         } catch (Exception e) {
 974             LOG.error("Exception during cleanup of VPNToExtraRoute for VPN {}", vpnName, e);
 975         }
 976     }
 977
 978     // TODO Clean up the exception handling
 979     @SuppressWarnings("checkstyle:IllegalCatch")
 980     public static void removeVpnOpInstance(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
 981         try {
 982             // Clean up VPNInstanceOpDataEntry
 983             if (writeTxn != null) {
 984                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName));
 985             } else {
 986                 delete(broker, LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName),
 987                     DEFAULT_CALLBACK);
 988             }
 989         } catch (Exception e) {
 990             LOG.error("Exception during cleanup of VPNInstanceOpDataEntry for VPN {}", vpnName, e);
 991         }
 992     }
 993
 994     // TODO Clean up the exception handling
 995     @SuppressWarnings("checkstyle:IllegalCatch")
 996     public static void removeVpnInstanceToVpnId(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
 997         try {
 998             if (writeTxn != null) {
 999                 writeTxn.delete(LogicalDatastoreType.CONFIGURATION, getVpnInstanceToVpnIdIdentifier(vpnName));
1000             } else {
1001                 delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnInstanceToVpnIdIdentifier(vpnName),
1002                     DEFAULT_CALLBACK);
1003             }
1004         } catch (Exception e) {
1005             LOG.error("Exception during clean up of VpnInstanceToVpnId for VPN {}", vpnName, e);
1006         }
1007     }
1008
1009     // TODO Clean up the exception handling
1010     @SuppressWarnings("checkstyle:IllegalCatch")
1011     public static void removeVpnIdToVpnInstance(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
1012         try {
1013             if (writeTxn != null) {
1014                 writeTxn.delete(LogicalDatastoreType.CONFIGURATION, getVpnIdToVpnInstanceIdentifier(vpnId));
1015             } else {
1016                 delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnIdToVpnInstanceIdentifier(vpnId),
1017                     DEFAULT_CALLBACK);
1018             }
1019         } catch (Exception e) {
1020             LOG.error("Exception during clean up of VpnIdToVpnInstance for VPNID {}", vpnId, e);
1021         }
1022     }
1023
1024     // TODO Clean up the exception handling
1025     @SuppressWarnings("checkstyle:IllegalCatch")
1026     public static void removeVrfTableForVpn(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
1027         // Clean up FIB Entries Config DS
1028         try {
1029             if (writeTxn != null) {
1030                 writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
1031                     InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class,
1032                         new VrfTablesKey(vpnName)).build());
1033             } else {
1034                 delete(broker, LogicalDatastoreType.CONFIGURATION,
1035                     InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class,
1036                         new VrfTablesKey(vpnName)).build(),
1037                     DEFAULT_CALLBACK);
1038             }
1039         } catch (Exception e) {
1040             LOG.error("Exception during clean up of VrfTable from FIB for VPN {}", vpnName, e);
1041         }
1042     }
1043
1044     // TODO Clean up the exception handling
1045     @SuppressWarnings("checkstyle:IllegalCatch")
1046     public static void removeL3nexthopForVpnId(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
1047         try {
1048             // Clean up L3NextHop Operational DS
1049             if (writeTxn != null) {
1050                 writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
1051                     InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class,
1052                         new VpnNexthopsKey(vpnId)).build());
1053             } else {
1054                 delete(broker, LogicalDatastoreType.OPERATIONAL,
1055                     InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class,
1056                         new VpnNexthopsKey(vpnId)).build(),
1057                     DEFAULT_CALLBACK);
1058             }
1059         } catch (Exception e) {
1060             LOG.error("Exception during cleanup of L3NextHop for VPN ID {}", vpnId, e);
1061         }
1062     }
1063
1064     public static void scheduleVpnInterfaceForRemoval(DataBroker broker,String interfaceName, BigInteger dpnId,
1065                                                       String vpnInstanceName, Boolean isScheduledToRemove,
1066                                                       WriteTransaction writeOperTxn) {
1067         InstanceIdentifier<VpnInterface> interfaceId = VpnUtil.getVpnInterfaceIdentifier(interfaceName);
1068         VpnInterface interfaceToUpdate =
1069             new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(interfaceName)).setName(interfaceName)
1070                 .setDpnId(dpnId).setVpnInstanceName(vpnInstanceName).setScheduledForRemove(isScheduledToRemove).build();
1071         if (writeOperTxn != null) {
1072             writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate, true);
1073         } else {
1074             VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate);
1075         }
1076     }
1077
1078     protected static void createLearntVpnVipToPort(DataBroker broker, String vpnName, String fixedIp, String
1079             portName, String macAddress) {
1080         synchronized ((vpnName + fixedIp).intern()) {
1081             InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
1082             LearntVpnVipToPortBuilder builder =
1083                     new LearntVpnVipToPortBuilder().setKey(new LearntVpnVipToPortKey(fixedIp, vpnName)).setVpnName(
1084                             vpnName).setPortFixedip(fixedIp).setPortName(portName).setMacAddress(
1085                             macAddress.toLowerCase());
1086             MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, builder.build());
1087             LOG.debug("ARP learned for fixedIp: {}, vpn {}, interface {}, mac {}, isSubnetIp {} added to "
1088                     + "VpnPortipToPort DS", fixedIp, vpnName, portName, macAddress);
1089         }
1090     }
1091
1092     private static InstanceIdentifier<LearntVpnVipToPort> buildLearntVpnVipToPortIdentifier(String vpnName,
1093             String fixedIp) {
1094         InstanceIdentifier<LearntVpnVipToPort> id =
1095                 InstanceIdentifier.builder(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class,
1096                         new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
1097         return id;
1098     }
1099
1100     protected static void removeLearntVpnVipToPort(DataBroker broker, String vpnName, String fixedIp) {
1101         synchronized ((vpnName + fixedIp).intern()) {
1102             InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
1103             MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, id);
1104             LOG.debug("Delete learned ARP for fixedIp: {}, vpn {} removed from VpnPortipToPort DS", fixedIp, vpnName);
1105         }
1106     }
1107
1108     static InstanceIdentifier<NetworkMap> buildNetworkMapIdentifier(Uuid networkId) {
1109         InstanceIdentifier<NetworkMap> id = InstanceIdentifier.builder(NetworkMaps.class).child(NetworkMap.class, new
1110                 NetworkMapKey(networkId)).build();
1111         return id;
1112     }
1113
1114     static InstanceIdentifier<SubnetOpDataEntry> buildSubnetOpDataEntryInstanceIdentifier(Uuid subnetId) {
1115         InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = InstanceIdentifier.builder(SubnetOpData.class)
1116                 .child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
1117         return subOpIdentifier;
1118     }
1119
1120     static InstanceIdentifier<VpnPortipToPort> buildVpnPortipToPortIdentifier(String vpnName, String fixedIp) {
1121         InstanceIdentifier<VpnPortipToPort> id =
1122             InstanceIdentifier.builder(NeutronVpnPortipPortData.class).child(VpnPortipToPort.class,
1123                 new VpnPortipToPortKey(fixedIp, vpnName)).build();
1124         return id;
1125     }
1126
1127     static VpnPortipToPort getNeutronPortFromVpnPortFixedIp(DataBroker broker, String vpnName, String fixedIp) {
1128         InstanceIdentifier id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
1129         Optional<VpnPortipToPort> vpnPortipToPortData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
1130         if (vpnPortipToPortData.isPresent()) {
1131             return (vpnPortipToPortData.get());
1132         }
1133         return null;
1134     }
1135
1136     static LearntVpnVipToPort getLearntVpnVipToPort(DataBroker broker, String vpnName, String fixedIp) {
1137         InstanceIdentifier id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
1138         Optional<LearntVpnVipToPort> learntVpnVipToPort = read(broker, LogicalDatastoreType.OPERATIONAL, id);
1139         if (learntVpnVipToPort.isPresent()) {
1140             return (learntVpnVipToPort.get());
1141         }
1142         return null;
1143     }
1144
1145     public static List<BigInteger> getDpnsOnVpn(DataBroker dataBroker, String vpnInstanceName) {
1146         List<BigInteger> result = new ArrayList<>();
1147         String rd = getVpnRd(dataBroker, vpnInstanceName);
1148         if (rd == null) {
1149             LOG.debug("Could not find Route-Distinguisher for VpnName={}", vpnInstanceName);
1150             return result;
1151         }
1152
1153         VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(dataBroker, rd);
1154         if (vpnInstanceOpData == null) {
1155             LOG.debug("Could not find OpState for VpnName={}", vpnInstanceName);
1156             return result;
1157         }
1158
1159         List<VpnToDpnList> vpnToDpnList = vpnInstanceOpData.getVpnToDpnList();
1160         if (vpnToDpnList == null) {
1161             LOG.debug("Could not find DPN footprint for VpnName={}", vpnInstanceName);
1162             return result;
1163         }
1164         for (VpnToDpnList vpnToDpn : vpnToDpnList) {
1165             result.add(vpnToDpn.getDpnId());
1166         }
1167         return result;
1168     }
1169
1170     static String getAssociatedExternalNetwork(DataBroker dataBroker, String routerId) {
1171         InstanceIdentifier<Routers> id = buildRouterIdentifier(routerId);
1172         Optional<Routers> routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
1173         if (routerData.isPresent()) {
1174             Uuid networkId = routerData.get().getNetworkId();
1175             if (networkId != null) {
1176                 return networkId.getValue();
1177             }
1178         }
1179         return null;
1180     }
1181
1182     static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
1183         InstanceIdentifier<Routers> routerInstanceIndentifier =
1184             InstanceIdentifier.builder(ExtRouters.class).child(Routers.class, new RoutersKey(routerId)).build();
1185         return routerInstanceIndentifier;
1186     }
1187
1188     static Networks getExternalNetwork(DataBroker dataBroker, Uuid networkId) {
1189         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
1190             .child(Networks.class, new NetworksKey(networkId)).build();
1191         Optional<Networks> optionalNets = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
1192         return optionalNets.isPresent() ? optionalNets.get() : null;
1193     }
1194
1195     static Uuid getExternalNetworkVpnId(DataBroker dataBroker, Uuid networkId) {
1196         Networks extNetwork = getExternalNetwork(dataBroker, networkId);
1197         return extNetwork != null ? extNetwork.getVpnid() : null;
1198     }
1199
1200     static List<Uuid> getExternalNetworkRouterIds(DataBroker dataBroker, Uuid networkId) {
1201         Networks extNetwork = getExternalNetwork(dataBroker, networkId);
1202         return extNetwork != null ? extNetwork.getRouterIds() : Collections.emptyList();
1203     }
1204
1205     static Routers getExternalRouter(DataBroker dataBroker, String routerId) {
1206         InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class)
1207                 .child(Routers.class, new RoutersKey(routerId)).build();
1208         Optional<Routers> routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
1209         return routerData.isPresent() ? routerData.get() : null;
1210     }
1211
1212     static List<String> getAllSubnetGatewayMacAddressesforVpn(DataBroker broker, String vpnName) {
1213         List<String> macAddresses = new ArrayList<>();
1214         Optional<Subnetmaps> subnetMapsData =
1215             read(broker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
1216         if (subnetMapsData.isPresent()) {
1217             List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
1218             if (subnetMapList != null && !subnetMapList.isEmpty()) {
1219                 for (Subnetmap subnet : subnetMapList) {
1220                     if (subnet.getVpnId() != null && subnet.getVpnId().equals(Uuid.getDefaultInstance(vpnName))) {
1221                         String routerIntfMacAddress = subnet.getRouterIntfMacAddress();
1222                         if (routerIntfMacAddress != null && !routerIntfMacAddress.isEmpty()) {
1223                             macAddresses.add(subnet.getRouterIntfMacAddress());
1224                         }
1225                     }
1226                 }
1227             }
1228         }
1229         return macAddresses;
1230     }
1231
1232     static InstanceIdentifier<Subnetmaps> buildSubnetMapsWildCardPath() {
1233         return InstanceIdentifier.create(Subnetmaps.class);
1234     }
1235
1236     static void setupSubnetMacIntoVpnInstance(DataBroker dataBroker, IMdsalApiManager mdsalManager, String vpnName,
1237             String subnetVpnName, String srcMacAddress, BigInteger dpnId, WriteTransaction writeTx, int addOrRemove) {
1238         long vpnId = getVpnId(dataBroker, vpnName);
1239         long subnetVpnId = VpnConstants.INVALID_ID;
1240         if (subnetVpnName != null) {
1241             subnetVpnId = getVpnId(dataBroker,subnetVpnName);
1242         }
1243
1244         if (dpnId.equals(BigInteger.ZERO)) {
1245             /* Apply the MAC on all DPNs in a VPN */
1246             List<BigInteger> dpIds = getDpnsOnVpn(dataBroker, vpnName);
1247             if (dpIds == null || dpIds.isEmpty()) {
1248                 return;
1249             }
1250             for (BigInteger dpId : dpIds) {
1251                 addGwMacIntoTx(mdsalManager, srcMacAddress, writeTx, addOrRemove, vpnId, dpId, subnetVpnId);
1252             }
1253         } else {
1254             addGwMacIntoTx(mdsalManager, srcMacAddress, writeTx, addOrRemove, vpnId, dpnId, subnetVpnId);
1255         }
1256     }
1257
1258     static void addGwMacIntoTx(IMdsalApiManager mdsalManager, String srcMacAddress, WriteTransaction writeTx,
1259         int addOrRemove, long vpnId, BigInteger dpId, long subnetVpnId) {
1260         FlowEntity flowEntity = buildL3vpnGatewayFlow(dpId, srcMacAddress, vpnId, subnetVpnId);
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             long subnetVpnId) {
1270         List<MatchInfo> mkMatches = new ArrayList<>();
1271         mkMatches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnId), MetaDataUtil.METADATA_MASK_VRFID));
1272         mkMatches.add(new MatchEthernetDestination(new MacAddress(gwMacAddress)));
1273         List<InstructionInfo> mkInstructions = new ArrayList<>();
1274         mkInstructions.add(new InstructionGotoTable(NwConstants.L3_FIB_TABLE));
1275         if (subnetVpnId != VpnConstants.INVALID_ID) {
1276             BigInteger subnetIdMetaData = MetaDataUtil.getVpnIdMetadata(subnetVpnId);
1277             mkInstructions.add(new InstructionWriteMetadata(subnetIdMetaData, MetaDataUtil.METADATA_MASK_VRFID));
1278         }
1279
1280         String flowId = getL3VpnGatewayFlowRef(NwConstants.L3_GW_MAC_TABLE, dpId, vpnId, gwMacAddress);
1281         FlowEntity flowEntity = MDSALUtil.buildFlowEntity(dpId, NwConstants.L3_GW_MAC_TABLE,
1282             flowId, 20, flowId, 0, 0, NwConstants.COOKIE_L3_GW_MAC_TABLE, mkMatches, mkInstructions);
1283         return flowEntity;
1284     }
1285
1286     private static String getL3VpnGatewayFlowRef(short l3GwMacTable, BigInteger dpId, long vpnId, String gwMacAddress) {
1287         return gwMacAddress + NwConstants.FLOWID_SEPARATOR + vpnId + NwConstants.FLOWID_SEPARATOR + dpId
1288             + NwConstants.FLOWID_SEPARATOR + l3GwMacTable;
1289     }
1290
1291     public static void lockSubnet(LockManagerService lockManager, String subnetId) {
1292         TryLockInput input =
1293             new TryLockInputBuilder().setLockName(subnetId).setTime(3000L).setTimeUnit(TimeUnits.Milliseconds).build();
1294         Future<RpcResult<Void>> result = lockManager.tryLock(input);
1295         String errMsg = "Unable to getLock for subnet " + subnetId;
1296         try {
1297             if ((result != null) && (result.get().isSuccessful())) {
1298                 LOG.debug("Acquired lock for {}", subnetId);
1299             } else {
1300                 throw new RuntimeException(errMsg);
1301             }
1302         } catch (InterruptedException | ExecutionException e) {
1303             LOG.error(errMsg);
1304             throw new RuntimeException(errMsg, e.getCause());
1305         }
1306     }
1307
1308     public static void unlockSubnet(LockManagerService lockManager, String subnetId) {
1309         UnlockInput input = new UnlockInputBuilder().setLockName(subnetId).build();
1310         Future<RpcResult<Void>> result = lockManager.unlock(input);
1311         try {
1312             if ((result != null) && (result.get().isSuccessful())) {
1313                 LOG.debug("Unlocked {}", subnetId);
1314             } else {
1315                 LOG.debug("Unable to unlock subnet {}", subnetId);
1316             }
1317         } catch (InterruptedException | ExecutionException e) {
1318             LOG.error("Unable to unlock subnet {}", subnetId);
1319             throw new RuntimeException(String.format("Unable to unlock subnetId %s", subnetId), e.getCause());
1320         }
1321     }
1322
1323     static Optional<IpAddress> getGatewayIpAddressFromInterface(String srcInterface,
1324             INeutronVpnManager neutronVpnService, DataBroker dataBroker) {
1325         Optional<IpAddress> gatewayIp = Optional.absent();
1326         if (neutronVpnService != null) {
1327             //TODO(Gobinath): Need to fix this as assuming port will belong to only one Subnet would be incorrect"
1328             Port port = neutronVpnService.getNeutronPort(srcInterface);
1329             if (port != null && port.getFixedIps() != null && port.getFixedIps().get(0) != null
1330                 && port.getFixedIps().get(0).getSubnetId() != null) {
1331                 gatewayIp = Optional.of(
1332                     neutronVpnService.getNeutronSubnet(port.getFixedIps().get(0).getSubnetId()).getGatewayIp());
1333             }
1334         } else {
1335             LOG.debug("neutron vpn service is not configured");
1336         }
1337         return gatewayIp;
1338     }
1339
1340     static Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp,
1341         DataBroker dataBroker, OdlInterfaceRpcService interfaceRpc) {
1342         Optional<String> gatewayMac = Optional.absent();
1343         long vpnId = getVpnId(dataBroker, macEntry.getVpnName());
1344         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
1345             .instance.VpnIds>
1346             vpnIdsInstanceIdentifier = VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId);
1347         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
1348             vpnIdsOptional
1349             = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
1350         if (!vpnIdsOptional.isPresent()) {
1351             LOG.trace("VPN {} not configured", vpnId);
1352             return gatewayMac;
1353         }
1354         VpnPortipToPort vpnTargetIpToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker,
1355             macEntry.getVpnName(), gatewayIp.getIpv4Address().getValue());
1356         if (vpnTargetIpToPort != null && vpnTargetIpToPort.isSubnetIp()) {
1357             gatewayMac = Optional.of(vpnTargetIpToPort.getMacAddress());
1358         } else {
1359             org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds vpnIds =
1360                 vpnIdsOptional.get();
1361             if (vpnIds.isExternalVpn()) {
1362                 gatewayMac = InterfaceUtils.getMacAddressForInterface(dataBroker, macEntry.getInterfaceName());
1363             }
1364         }
1365         return gatewayMac;
1366     }
1367
1368     public static void runOnlyInLeaderNode(EntityOwnershipService entityOwnershipService, Runnable job) {
1369         runOnlyInLeaderNode(entityOwnershipService, job, "");
1370     }
1371
1372     public static void runOnlyInLeaderNode(EntityOwnershipService entityOwnershipService, final Runnable job,
1373             final String jobDescription) {
1374         ListenableFuture<Boolean> checkEntityOwnerFuture = ClusteringUtils.checkNodeEntityOwner(
1375                 entityOwnershipService, VpnConstants.ARP_MONITORING_ENTITY,
1376                 VpnConstants.ARP_MONITORING_ENTITY);
1377         Futures.addCallback(checkEntityOwnerFuture, new FutureCallback<Boolean>() {
1378             @Override
1379             public void onSuccess(Boolean isOwner) {
1380                 if (isOwner) {
1381                     job.run();
1382                 } else {
1383                     LOG.trace("job is not run as i m not cluster owner desc :{} ", jobDescription);
1384                 }
1385             }
1386
1387             @Override
1388             public void onFailure(Throwable error) {
1389                 LOG.error("Failed to identity cluster owner ", error);
1390             }
1391         });
1392     }
1393
1394     public static boolean isVpnIntfPresentInVpnToDpnList(DataBroker broker, VpnInterface vpnInterface) {
1395         BigInteger dpnId = vpnInterface.getDpnId();
1396         String rd = VpnUtil.getVpnRd(broker, vpnInterface.getVpnInstanceName());
1397         LOG.trace("GOT rd {} for VpnInterface {}  VpnInstance {} ", rd ,
1398                 vpnInterface.getName(), vpnInterface.getVpnInstanceName());
1399         VpnInstanceOpDataEntry vpnInstanceOpData = VpnUtil.getVpnInstanceOpDataFromCache(broker, rd);
1400         if (vpnInstanceOpData != null) {
1401             LOG.trace("GOT VpnInstanceOp {} for rd {} ", vpnInstanceOpData, rd);
1402             List<VpnToDpnList> dpnToVpns = vpnInstanceOpData.getVpnToDpnList();
1403             if (dpnToVpns != null) {
1404                 for (VpnToDpnList dpn : dpnToVpns) {
1405                     if (dpn.getDpnId().equals(dpnId)) {
1406                         return dpn.getVpnInterfaces().contains(vpnInterface.getName());
1407                     }
1408                     LOG.trace("VpnInterface {} not present in DpnId {} ", vpnInterface.getName(), dpn.getDpnId());
1409                 }
1410             }
1411         }
1412         return false;
1413     }
1414
1415     public static void setupGwMacIfExternalVpn(DataBroker dataBroker, IMdsalApiManager mdsalManager, BigInteger dpnId,
1416             String interfaceName, long vpnId, WriteTransaction writeInvTxn, int addOrRemove, org.opendaylight.yang.gen
1417             .v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface interfaceState) {
1418         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
1419             .VpnIds> vpnIdsInstanceIdentifier = getVpnIdToVpnInstanceIdentifier(vpnId);
1420         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
1421             .VpnIds> vpnIdsOptional = read(
1422                 dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
1423         if (vpnIdsOptional.isPresent() && vpnIdsOptional.get().isExternalVpn()) {
1424             PhysAddress gwMacAddress = interfaceState.getPhysAddress();
1425             if (gwMacAddress == null) {
1426                 LOG.error("Failed to get gwMacAddress for interface {}", interfaceName);
1427                 return;
1428             }
1429
1430             String gwMac = gwMacAddress.getValue();
1431             FlowEntity flowEntity = VpnUtil.buildL3vpnGatewayFlow(dpnId, gwMac, vpnId, VpnConstants.INVALID_ID);
1432             if (addOrRemove == NwConstants.ADD_FLOW) {
1433                 mdsalManager.addFlowToTx(flowEntity, writeInvTxn);
1434             } else if (addOrRemove == NwConstants.DEL_FLOW) {
1435                 mdsalManager.removeFlowToTx(flowEntity, writeInvTxn);
1436             }
1437         }
1438     }
1439
1440     public static Optional<VpnPortipToPort> getRouterInterfaceForVpnInterface(DataBroker dataBroker,
1441                                                                               String interfaceName,
1442                                                                               String vpnName,
1443                                                                               Uuid subnetUuid) {
1444         Optional<VpnPortipToPort> gwPortOptional = Optional.absent();
1445         if (subnetUuid != null) {
1446             final Optional<String> gatewayIp = getVpnSubnetGatewayIp(dataBroker, subnetUuid);
1447             if (gatewayIp.isPresent()) {
1448                 String gwIp = gatewayIp.get();
1449                 gwPortOptional = Optional.fromNullable(getNeutronPortFromVpnPortFixedIp(dataBroker, vpnName, gwIp));
1450             }
1451         }
1452         return gwPortOptional;
1453     }
1454
1455     public static Optional<String> getVpnSubnetGatewayIp(DataBroker dataBroker, final Uuid subnetUuid) {
1456         Optional<String> gwIpAddress = Optional.absent();
1457         final SubnetKey subnetkey = new SubnetKey(subnetUuid);
1458         final InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class)
1459                 .child(Subnets.class)
1460                 .child(Subnet.class, subnetkey);
1461         final Optional<Subnet> subnet = read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetidentifier);
1462         if (subnet.isPresent()) {
1463             Class<? extends IpVersionBase> ipVersionBase = subnet.get().getIpVersion();
1464             if (ipVersionBase.equals(IpVersionV4.class)) {
1465                 LOG.trace("Obtained subnet {} for vpn interface", subnet.get().getUuid().getValue());
1466                 gwIpAddress = Optional.of(subnet.get().getGatewayIp().getIpv4Address().getValue());
1467                 return gwIpAddress;
1468             }
1469         }
1470         return gwIpAddress;
1471     }
1472
1473     public static RouterToNaptSwitch getRouterToNaptSwitch(DataBroker dataBroker, String routerName) {
1474         InstanceIdentifier<RouterToNaptSwitch> id = InstanceIdentifier.builder(NaptSwitches.class)
1475                 .child(RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerName)).build();
1476         Optional<RouterToNaptSwitch> routerToNaptSwitchData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
1477         return routerToNaptSwitchData.isPresent() ? routerToNaptSwitchData.get() : null;
1478     }
1479
1480     static InstanceIdentifier<Subnetmap> buildSubnetmapIdentifier(Uuid subnetId) {
1481         return (InstanceIdentifier<Subnetmap>) InstanceIdentifier.builder(Subnetmaps.class)
1482         .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
1483
1484     }
1485
1486     public static BigInteger getPrimarySwitchForRouter(DataBroker dataBroker, String routerName) {
1487         RouterToNaptSwitch routerToNaptSwitch = getRouterToNaptSwitch(dataBroker, routerName);
1488         return routerToNaptSwitch != null ? routerToNaptSwitch.getPrimarySwitchId() : null;
1489     }
1490
1491     static boolean isL3VpnOverVxLan(Long l3Vni) {
1492         return (l3Vni != null && l3Vni != 0);
1493     }
1494
1495     static boolean isEvpnOverVxLan(Long l2Vni) { //To be used by RT2
1496         return (l2Vni != null && l2Vni != 0);
1497     }
1498
1499     /**
1500      * Retrieves the primary rd of a vpn instance
1501      * Primary rd will be the first rd in the list of rds configured for a vpn instance
1502      * If rd list is empty, primary rd will be vpn instance name
1503      * Use this function only during create operation cycles. For other operations, use getVpnRd() method.
1504      *
1505      * @param dataBroker dataBroker service reference
1506      * @param vpnName Name of the VPN
1507      * @return the primary rd of the VPN
1508      */
1509     public static String getPrimaryRd(DataBroker dataBroker, String vpnName) {
1510         InstanceIdentifier<VpnInstance> id  = getVpnInstanceIdentifier(vpnName);
1511         Optional<VpnInstance> vpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
1512         if (vpnInstance.isPresent()) {
1513             return getPrimaryRd(vpnInstance.get());
1514         }
1515         return vpnName;
1516     }
1517
1518     /**
1519      * Retrieves the primary rd of a vpn instance
1520      * Primary rd will be the first rd in the list of rds configured for a vpn instance
1521      * If rd list is empty, primary rd will be vpn instance name
1522      * Use this function only during create operation cycles. For other operations, use getVpnRd() method.
1523      *
1524      * @param vpnInstance Config Vpn Instance Object
1525      * @return the primary rd of the VPN
1526      */
1527     public static String getPrimaryRd(VpnInstance vpnInstance) {
1528         List<String> rds = null;
1529         if (vpnInstance != null) {
1530             rds = getListOfRdsFromVpnInstance(vpnInstance);
1531         }
1532         return rds == null || rds.isEmpty() ? vpnInstance.getVpnInstanceName() : rds.get(0);
1533     }
1534
1535     public static boolean isBgpVpn(String vpnName, String primaryRd) {
1536         return !vpnName.equals(primaryRd);
1537     }
1538
1539     static java.util.Optional<String> allocateRdForExtraRouteAndUpdateUsedRdsMap(
1540             DataBroker dataBroker, long vpnId, Optional<Long> parentVpnId, String prefix, String vpnName,
1541             BigInteger dpnId, WriteTransaction writeOperTxn) {
1542         List<String> usedRds = getUsedRds(dataBroker, vpnId, prefix);
1543         //Check if rd is already allocated for the same prefix. Use same rd if extra route is behind same CSS.
1544         java.util.Optional<String> rdToAllocate = usedRds.stream()
1545                 .map(usedRd -> {
1546                     Optional<Routes> vpnExtraRoutes = VpnExtraRouteHelper.getVpnExtraroutes(dataBroker,
1547                             vpnName, usedRd, prefix);
1548                     return vpnExtraRoutes.isPresent() ? new ImmutablePair<String, String>(
1549                             vpnExtraRoutes.get().getNexthopIpList().get(0),
1550                             usedRd) : new ImmutablePair<>("", "");
1551                 })
1552                 .filter(pair -> {
1553                     if (pair.getLeft().isEmpty()) {
1554                         return false;
1555                     }
1556                     Optional<Prefixes> prefixToInterface;
1557                     //In case of VPN importing the routes, the interface is not present in the VPN
1558                     //and has to be fetched from the VPN from which it imports
1559                     if (parentVpnId.isPresent()) {
1560                         prefixToInterface = getPrefixToInterface(dataBroker, parentVpnId.get(), pair.getLeft());
1561                     } else {
1562                         prefixToInterface = getPrefixToInterface(dataBroker, vpnId, pair.getLeft());
1563                     }
1564                     return prefixToInterface.isPresent() ? dpnId.equals(prefixToInterface.get().getDpnId()) : false;
1565                 }).map(pair -> pair.getRight()).findFirst();
1566         if (rdToAllocate.isPresent()) {
1567             return rdToAllocate;
1568         }
1569         List<String> availableRds = getVpnRdsFromVpnInstanceConfig(dataBroker, vpnName);
1570         if (availableRds.isEmpty()) {
1571             LOG.debug("Internal vpn. Returning vpn name {} as rd", vpnName);
1572             usedRds.add(vpnName);
1573             syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, getUsedRdsIdentifier(vpnId, prefix),
1574                     getDestPrefixesBuilder(prefix, usedRds).build());
1575             return java.util.Optional.ofNullable(vpnName);
1576         }
1577         LOG.trace(
1578                 "Removing used rds {} from available rds {} vpnid {} . prefix is {} , vpname- {}, dpnId- {}, adj - {}",
1579                 usedRds, availableRds, vpnId, prefix, vpnName, dpnId);
1580         availableRds.removeAll(usedRds);
1581         if (availableRds.isEmpty()) {
1582             LOG.error("No rd available from VpnInstance to allocate for prefix {}", prefix);
1583             return java.util.Optional.empty();
1584         }
1585         // If rd is not allocated for this prefix or if extra route is behind different CSS, select a new rd.
1586         String rd = availableRds.get(0);
1587         usedRds.add(rd);
1588         syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, getUsedRdsIdentifier(vpnId, prefix),
1589                 getDestPrefixesBuilder(prefix, usedRds).build());
1590         return java.util.Optional.ofNullable(rd);
1591     }
1592
1593     static String getVpnNamePrefixKey(String vpnName, String prefix) {
1594         return vpnName + VpnConstants.SEPARATOR + prefix;
1595     }
1596
1597     public static List<String> getIpsListFromExternalIps(List<ExternalIps> externalIps) {
1598         if (externalIps == null) {
1599             return Collections.emptyList();
1600         }
1601
1602         return externalIps.stream().map(externalIp -> externalIp.getIpAddress()).collect(Collectors.toList());
1603     }
1604
1605     static void bindService(final String vpnInstanceName, final String interfaceName, DataBroker dataBroker,
1606                             boolean isTunnelInterface) {
1607         DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
1608         dataStoreCoordinator.enqueueJob(interfaceName,
1609             () -> {
1610                 WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
1611                 BoundServices serviceInfo = isTunnelInterface
1612                         ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
1613                         : getBoundServicesForVpnInterface(dataBroker, vpnInstanceName, interfaceName);
1614                 writeTxn.put(LogicalDatastoreType.CONFIGURATION, InterfaceUtils.buildServiceId(interfaceName,
1615                         ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME, NwConstants.L3VPN_SERVICE_INDEX)),
1616                         serviceInfo, true);
1617                 List<ListenableFuture<Void>> futures = new ArrayList<>();
1618                 futures.add(writeTxn.submit());
1619                 return futures;
1620             });
1621     }
1622
1623     static BoundServices getBoundServicesForVpnInterface(DataBroker broker, String vpnName, String interfaceName) {
1624         List<Instruction> instructions = new ArrayList<>();
1625         int instructionKey = 0;
1626         final long vpnId = VpnUtil.getVpnId(broker, vpnName);
1627         List<Action> actions = Collections.singletonList(
1628                 new ActionRegLoad(0, VpnConstants.VPN_REG_ID, 0, VpnConstants.VPN_ID_LENGTH, vpnId).buildAction());
1629         instructions.add(MDSALUtil.buildApplyActionsInstruction(actions, ++instructionKey));
1630         instructions.add(
1631                 MDSALUtil.buildAndGetWriteMetadaInstruction(MetaDataUtil.getVpnIdMetadata(vpnId),
1632                         MetaDataUtil.METADATA_MASK_VRFID, ++instructionKey));
1633         instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.L3_GW_MAC_TABLE,
1634                 ++instructionKey));
1635         BoundServices serviceInfo = InterfaceUtils.getBoundServices(
1636                 String.format("%s.%s.%s", "vpn", vpnName, interfaceName),
1637                 ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME, NwConstants.L3VPN_SERVICE_INDEX),
1638                 VpnConstants.DEFAULT_FLOW_PRIORITY, NwConstants.COOKIE_VM_INGRESS_TABLE, instructions);
1639         return serviceInfo;
1640     }
1641
1642     static BoundServices getBoundServicesForTunnelInterface(String vpnName, String interfaceName) {
1643         int instructionKey = 0;
1644         List<Instruction> instructions = new ArrayList<>();
1645         instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(
1646                 NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, ++instructionKey));
1647         BoundServices serviceInfo = InterfaceUtils.getBoundServices(String.format("%s.%s.%s", "vpn",
1648                 vpnName, interfaceName),
1649                 ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
1650                         NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE), VpnConstants.DEFAULT_FLOW_PRIORITY,
1651                 NwConstants.COOKIE_VM_INGRESS_TABLE, instructions);
1652         return serviceInfo;
1653     }
1654
1655     static void unbindService(DataBroker dataBroker, final String vpnInterfaceName, boolean isInterfaceStateDown,
1656                                boolean isConfigRemoval) {
1657         if (!isInterfaceStateDown && isConfigRemoval) {
1658             DataStoreJobCoordinator dataStoreCoordinator = DataStoreJobCoordinator.getInstance();
1659             dataStoreCoordinator.enqueueJob(vpnInterfaceName,
1660                 () -> {
1661                     WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
1662                     writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
1663                             InterfaceUtils.buildServiceId(vpnInterfaceName,
1664                                     ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
1665                                             NwConstants.L3VPN_SERVICE_INDEX)));
1666
1667                     List<ListenableFuture<Void>> futures = new ArrayList<>();
1668                     futures.add(writeTxn.submit());
1669                     return futures;
1670                 });
1671         }
1672     }
1673
1674     static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId) {
1675         FlowEntity flowEntity = new FlowEntity(dpnId);
1676         flowEntity.setTableId(tableId);
1677         flowEntity.setFlowId(flowId);
1678         return flowEntity;
1679     }
1680
1681     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
1682         .Subnets getExternalSubnet(DataBroker dataBroker, Uuid subnetId) {
1683         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
1684             .Subnets> subnetsIdentifier = InstanceIdentifier.builder(ExternalSubnets.class)
1685                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
1686                         .Subnets.class, new SubnetsKey(subnetId)).build();
1687         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets>
1688             optionalSubnets = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
1689         return optionalSubnets.isPresent() ? optionalSubnets.get() : null;
1690     }
1691
1692     static Uuid getSubnetFromExternalRouterByIp(DataBroker dataBroker, Uuid routerId, String ip) {
1693         Routers externalRouter = VpnUtil.getExternalRouter(dataBroker, routerId.getValue());
1694         if (externalRouter != null && externalRouter.getExternalIps() != null) {
1695             for (ExternalIps externalIp : externalRouter.getExternalIps()) {
1696                 if (externalIp.getIpAddress().equals(ip)) {
1697                     return externalIp.getSubnetId();
1698                 }
1699             }
1700         }
1701         return null;
1702     }
1703 }