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.collect.Iterators;
  13 import com.google.common.net.InetAddresses;
  14 import com.google.common.util.concurrent.FutureCallback;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16 import java.math.BigInteger;
  17 import java.net.Inet4Address;
  18 import java.net.Inet6Address;
  19 import java.net.InetAddress;
  20 import java.net.UnknownHostException;
  21 import java.text.SimpleDateFormat;
  22 import java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.Collections;
  25 import java.util.Date;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.List;
  29 import java.util.Locale;
  30 import java.util.Map;
  31 import java.util.Map.Entry;
  32 import java.util.Set;
  33 import java.util.concurrent.ExecutionException;
  34 import java.util.concurrent.Future;
  35 import java.util.function.Predicate;
  36 import java.util.stream.Collectors;
  37 import javax.annotation.Nonnull;
  38 import javax.annotation.Nullable;
  39 import javax.inject.Singleton;
  40
  41 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  42 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  43 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  44 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  45 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  46 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  47 import org.opendaylight.genius.infra.Datastore;
  48 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
  49 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
  50 import org.opendaylight.genius.infra.TypedWriteTransaction;
  51 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  52 import org.opendaylight.genius.mdsalutil.FlowEntity;
  53 import org.opendaylight.genius.mdsalutil.FlowEntityBuilder;
  54 import org.opendaylight.genius.mdsalutil.InstructionInfo;
  55 import org.opendaylight.genius.mdsalutil.MDSALUtil;
  56 import org.opendaylight.genius.mdsalutil.MatchInfo;
  57 import org.opendaylight.genius.mdsalutil.MetaDataUtil;
  58 import org.opendaylight.genius.mdsalutil.NWUtil;
  59 import org.opendaylight.genius.mdsalutil.NwConstants;
  60 import org.opendaylight.genius.mdsalutil.actions.ActionRegLoad;
  61 import org.opendaylight.genius.mdsalutil.instructions.InstructionGotoTable;
  62 import org.opendaylight.genius.mdsalutil.instructions.InstructionWriteMetadata;
  63 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  64 import org.opendaylight.genius.mdsalutil.matches.MatchEthernetDestination;
  65 import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
  66 import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
  67 import org.opendaylight.genius.utils.ServiceIndex;
  68 import org.opendaylight.genius.utils.SystemPropertyReader;
  69 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  70 import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
  71 import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
  72 import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
  73 import org.opendaylight.netvirt.fibmanager.api.FibHelper;
  74 import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
  75 import org.opendaylight.netvirt.neutronvpn.api.enums.IpVersionChoice;
  76 import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
  77 import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
  78 import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
  79 import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
  80 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
  81 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
  82 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
  83 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
  84 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
  85 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
  86 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
  88 import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNames;
  89 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  90 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
  91 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
  92 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  93 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  94 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  95 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.list.Action;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
 107 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
 108 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInput;
 109 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexInputBuilder;
 110 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutput;
 111 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
 112 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
 113 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.Ipv6NdUtilService;
 114 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.SendNeighborSolicitationToOfGroupInput;
 115 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.SendNeighborSolicitationToOfGroupInputBuilder;
 116 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.SendNeighborSolicitationToOfGroupOutput;
 117 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
 118 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TimeUnits;
 119 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInput;
 120 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInputBuilder;
 121 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockOutput;
 122 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
 123 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInputBuilder;
 124 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutput;
 125 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
 126 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
 127 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanTagNameMap;
 128 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.SegmentTypeVlan;
 129 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesList;
 130 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.ElanDpnInterfacesListKey;
 131 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfaces;
 132 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfacesBuilder;
 133 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.dpn.interfaces.elan.dpn.interfaces.list.DpnInterfacesKey;
 134 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.instances.ElanInstance;
 135 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterface;
 136 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.interfaces.ElanInterfaceKey;
 137 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagName;
 138 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.elan.tag.name.map.ElanTagNameKey;
 139 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
 140 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.VrfEntryBase;
 141 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.dest.prefixes.AllocatedRdsBuilder;
 142 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.extraroute.rds.map.extraroute.rds.dest.prefixes.AllocatedRdsKey;
 143 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTables;
 144 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
 145 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
 146 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
 147 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.L3nexthop;
 148 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthops;
 149 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
 150 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
 151 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
 152 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOp;
 153 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOpBuilder;
 154 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
 155 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventAction;
 156 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventData;
 157 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PrefixToInterface;
 158 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
 159 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetsAssociatedToRouteTargets;
 160 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnIdToVpnInstance;
 161 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
 162 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInterfaceOpData;
 163 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnToExtraroutes;
 164 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
 165 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency.AdjacencyType;
 166 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyKey;
 167 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
 168 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortBuilder;
 169 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortKey;
 170 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.event.data.LearntVpnVipToPortEvent;
 171 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.event.data.LearntVpnVipToPortEventBuilder;
 172 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.event.data.LearntVpnVipToPortEventKey;
 173 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIds;
 174 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsKey;
 175 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
 176 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
 177 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesKey;
 178 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntry;
 179 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
 180 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.RouteTarget;
 181 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.RouteTargetKey;
 182 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.AssociatedSubnet;
 183 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.AssociatedSubnetKey;
 184 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.associated.subnet.AssociatedVpn;
 185 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.associated.subnet.AssociatedVpnBuilder;
 186 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.associated.subnet.AssociatedVpnKey;
 187 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntry;
 188 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntryBuilder;
 189 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntryKey;
 190 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
 191 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
 192 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnTargets;
 193 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
 194 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
 195 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder;
 196 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.Vpn;
 197 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.VpnKey;
 198 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
 199 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.RoutesBuilder;
 200 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExtRouters;
 201 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
 202 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalSubnets;
 203 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.NaptSwitches;
 204 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.Routers;
 205 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.RoutersKey;
 206 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ext.routers.routers.ExternalIps;
 207 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
 208 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
 209 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.SubnetsKey;
 210 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
 211 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchKey;
 212 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkAttributes.NetworkType;
 213 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
 214 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortipPortData;
 215 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
 216 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
 217 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
 218 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
 219 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortKey;
 220 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
 221 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
 222 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionBase;
 223 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionV4;
 224 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.ext.rev150712.NetworkL3Extension;
 225 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
 226 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.NetworkKey;
 227 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
 228 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
 229 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
 230 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
 231 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet;
 232 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
 233 import org.opendaylight.yangtools.yang.binding.DataObject;
 234 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 235 import org.opendaylight.yangtools.yang.common.RpcResult;
 236 import org.slf4j.Logger;
 237 import org.slf4j.LoggerFactory;
 238
 239 @Singleton
 240 public final class VpnUtil {
 241
 242     private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
 243
 244     static final int SINGLE_TRANSACTION_BROKER_NO_RETRY = 1;
 245
 246     private final DataBroker dataBroker;
 247     private final IdManagerService idManager;
 248     private final IBgpManager bgpManager;
 249     private final LockManagerService lockManager;
 250     private final INeutronVpnManager neutronVpnService;
 251     private final IMdsalApiManager mdsalManager;
 252     private final IInterfaceManager interfaceManager;
 253     private final JobCoordinator jobCoordinator;
 254     private final ManagedNewTransactionRunner txRunner;
 255     private final OdlInterfaceRpcService ifmRpcService;
 256
 257     /**
 258      * Class to generate timestamps with microsecond precision.
 259      * For example: MicroTimestamp.INSTANCE.get() = "2012-10-21 19:13:45.267128"
 260      */
 261     public enum MicroTimestamp {
 262         INSTANCE ;
 263
 264         private long              startDate ;
 265         private long              startNanoseconds ;
 266         private SimpleDateFormat  dateFormat ;
 267
 268         MicroTimestamp() {
 269             this.startDate = System.currentTimeMillis() ;
 270             this.startNanoseconds = System.nanoTime() ;
 271             this.dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;
 272         }
 273
 274         public String get() {
 275             long microSeconds = (System.nanoTime() - this.startNanoseconds) / 1000 ;
 276             long date = this.startDate + microSeconds / 1000 ;
 277             return this.dateFormat.format(date) + String.format("%03d", microSeconds % 1000) ;
 278         }
 279     }
 280
 281     public VpnUtil(DataBroker dataBroker, IdManagerService idManager, IBgpManager bgpManager,
 282                    LockManagerService lockManager, INeutronVpnManager neutronVpnService,
 283                    IMdsalApiManager mdsalManager, JobCoordinator jobCoordinator,
 284                    IInterfaceManager interfaceManager, OdlInterfaceRpcService ifmRpcService) {
 285         this.dataBroker = dataBroker;
 286         this.idManager = idManager;
 287         this.bgpManager = bgpManager;
 288         this.lockManager = lockManager;
 289         this.neutronVpnService = neutronVpnService;
 290         this.mdsalManager = mdsalManager;
 291         this.interfaceManager = interfaceManager;
 292         this.jobCoordinator = jobCoordinator;
 293         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
 294         this.ifmRpcService = ifmRpcService;
 295     }
 296
 297     public static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
 298         return InstanceIdentifier.builder(VpnInterfaces.class)
 299                 .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
 300     }
 301
 302     static InstanceIdentifier<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntryIdentifier(String vpnInterfaceName,
 303                                                                                      String vpnName) {
 304         return InstanceIdentifier.builder(VpnInterfaceOpData.class).child(VpnInterfaceOpDataEntry.class,
 305             new VpnInterfaceOpDataEntryKey(vpnInterfaceName, vpnName)).build();
 306     }
 307
 308     static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
 309         return InstanceIdentifier.builder(VpnInstances.class)
 310                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 311     }
 312
 313     VpnInterface getVpnInterface(String vpnInterfaceName) {
 314         InstanceIdentifier<VpnInterface> id = getVpnInterfaceIdentifier(vpnInterfaceName);
 315         Optional<VpnInterface> vpnInterface = read(LogicalDatastoreType.CONFIGURATION, id);
 316         return vpnInterface.isPresent() ? vpnInterface.get() : null;
 317     }
 318
 319     static VpnInterfaceOpDataEntry getVpnInterfaceOpDataEntry(String intfName, String vpnName, AdjacenciesOp aug,
 320                                                        BigInteger dpnId, Boolean isSheduledForRemove, long lportTag,
 321                                                        String gwMac) {
 322         return new VpnInterfaceOpDataEntryBuilder().withKey(new VpnInterfaceOpDataEntryKey(intfName, vpnName))
 323             .setDpnId(dpnId).setScheduledForRemove(isSheduledForRemove).addAugmentation(AdjacenciesOp.class, aug)
 324                 .setLportTag(lportTag).setGatewayMacAddress(gwMac).build();
 325     }
 326
 327     Optional<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntry(String vpnInterfaceName, String vpnName) {
 328         InstanceIdentifier<VpnInterfaceOpDataEntry> id = getVpnInterfaceOpDataEntryIdentifier(vpnInterfaceName,
 329                                                                                               vpnName);
 330         Optional<VpnInterfaceOpDataEntry> vpnInterfaceOpDataEntry = read(LogicalDatastoreType.OPERATIONAL,
 331                 id);
 332         return vpnInterfaceOpDataEntry;
 333     }
 334
 335     static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(long vpnId, String ipPrefix) {
 336         return InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId))
 337                 .child(Prefixes.class, new PrefixesKey(ipPrefix)).build();
 338     }
 339
 340     static InstanceIdentifier<VpnIds> getPrefixToInterfaceIdentifier(long vpnId) {
 341         return InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build();
 342     }
 343
 344     static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix, Uuid subnetId,
 345             Prefixes.PrefixCue prefixCue) {
 346         return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(vpnInterfaceName).setIpAddress(ipPrefix)
 347                 .setSubnetId(subnetId).setPrefixCue(prefixCue).build();
 348     }
 349
 350     Optional<Prefixes> getPrefixToInterface(long vpnId, String ipPrefix) {
 351         return read(LogicalDatastoreType.OPERATIONAL, getPrefixToInterfaceIdentifier(vpnId, getIpPrefix(ipPrefix)));
 352     }
 353
 354     /**
 355      * Get VRF table given a Route Distinguisher.
 356      *
 357      * @param rd Route-Distinguisher
 358      * @return VrfTables that holds the list of VrfEntries of the specified rd
 359      */
 360     VrfTables getVrfTable(String rd) {
 361         InstanceIdentifier<VrfTables> id = InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class,
 362                 new VrfTablesKey(rd)).build();
 363         Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, id);
 364         return vrfTable.isPresent() ? vrfTable.get() : null;
 365     }
 366
 367     /**
 368      * Retrieves the VrfEntries that belong to a given VPN filtered out by
 369      * Origin, searching by its Route-Distinguisher.
 370      *
 371      * @param rd Route-distinguisher of the VPN
 372      * @param originsToConsider Only entries whose origin is included in this list will be considered
 373      * @return the list of VrfEntries
 374      */
 375     public List<VrfEntry> getVrfEntriesByOrigin(String rd, List<RouteOrigin> originsToConsider) {
 376         List<VrfEntry> result = new ArrayList<>();
 377         List<VrfEntry> allVpnVrfEntries = getAllVrfEntries(rd);
 378         for (VrfEntry vrfEntry : allVpnVrfEntries) {
 379             if (originsToConsider.contains(RouteOrigin.value(vrfEntry.getOrigin()))) {
 380                 result.add(vrfEntry);
 381             }
 382         }
 383         return result;
 384     }
 385
 386     /**
 387      * Retrieves all the VrfEntries that belong to a given VPN searching by its
 388      * Route-Distinguisher.
 389      *
 390      * @param rd Route-distinguisher of the VPN
 391      * @return the list of VrfEntries
 392      */
 393     public List<VrfEntry> getAllVrfEntries(String rd) {
 394         VrfTables vrfTables = getVrfTable(rd);
 395         return vrfTables != null ? vrfTables.getVrfEntry() : new ArrayList<>();
 396     }
 397
 398     //FIXME: Implement caches for DS reads
 399     public VpnInstance getVpnInstance(String vpnInstanceName) {
 400         InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,
 401             new VpnInstanceKey(vpnInstanceName)).build();
 402         Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
 403         return vpnInstance.isPresent() ? vpnInstance.get() : null;
 404     }
 405
 406     List<VpnInstanceOpDataEntry> getAllVpnInstanceOpData() {
 407         InstanceIdentifier<VpnInstanceOpData> id = InstanceIdentifier.builder(VpnInstanceOpData.class).build();
 408         Optional<VpnInstanceOpData> vpnInstanceOpDataOptional = read(LogicalDatastoreType.OPERATIONAL, id);
 409         return vpnInstanceOpDataOptional.isPresent() ?  vpnInstanceOpDataOptional.get().getVpnInstanceOpDataEntry()
 410                 : Collections.emptyList();
 411     }
 412
 413     List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
 414             .vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> getDpnVpnInterfaces(VpnInstance vpnInstance,
 415                                                                                            BigInteger dpnId) {
 416         String primaryRd = getPrimaryRd(vpnInstance);
 417         InstanceIdentifier<VpnToDpnList> dpnToVpnId = VpnHelper.getVpnToDpnListIdentifier(primaryRd, dpnId);
 418         Optional<VpnToDpnList> dpnInVpn = read(LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
 419         return dpnInVpn.isPresent() ? dpnInVpn.get().getVpnInterfaces() : Collections.emptyList();
 420     }
 421
 422     static List<String> getListOfRdsFromVpnInstance(VpnInstance vpnInstance) {
 423         VpnAfConfig vpnConfig = vpnInstance.getIpv4Family();
 424         LOG.trace("vpnConfig {}", vpnConfig);
 425         return vpnConfig.getRouteDistinguisher() != null ? vpnConfig.getRouteDistinguisher() : Collections.emptyList();
 426     }
 427
 428     VrfEntry getVrfEntry(String rd, String ipPrefix) {
 429         VrfTables vrfTable = getVrfTable(rd);
 430         // TODO: why check VrfTables if we later go for the specific VrfEntry?
 431         if (vrfTable != null) {
 432             InstanceIdentifier<VrfEntry> vrfEntryId =
 433                 InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
 434                     VrfEntry.class, new VrfEntryKey(ipPrefix)).build();
 435             Optional<VrfEntry> vrfEntry = read(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
 436             if (vrfEntry.isPresent()) {
 437                 return vrfEntry.get();
 438             }
 439         }
 440         return null;
 441     }
 442
 443     public List<Adjacency> getAdjacenciesForVpnInterfaceFromConfig(String intfName) {
 444         final InstanceIdentifier<VpnInterface> identifier = getVpnInterfaceIdentifier(intfName);
 445         InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
 446         Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.CONFIGURATION, path);
 447         if (adjacencies.isPresent()) {
 448             List<Adjacency> nextHops = adjacencies.get().getAdjacency();
 449             return nextHops;
 450         }
 451         return null;
 452     }
 453
 454     static Routes getVpnToExtraroute(String ipPrefix, List<String> nextHopList) {
 455         return new RoutesBuilder().setPrefix(ipPrefix).setNexthopIpList(nextHopList).build();
 456     }
 457
 458     String getVpnInterfaceName(BigInteger metadata) throws InterruptedException, ExecutionException {
 459         GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
 460         BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata);
 461         ifIndexInputBuilder.setIfIndex(lportTag.intValue());
 462         GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
 463         Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex =
 464                 ifmRpcService.getInterfaceFromIfIndex(input);
 465         GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput;
 466         RpcResult<GetInterfaceFromIfIndexOutput> rpcResult = interfaceFromIfIndex.get();
 467         if (rpcResult == null) {
 468             return null;
 469         }
 470         interfaceFromIfIndexOutput = rpcResult.getResult();
 471         return interfaceFromIfIndexOutput.getInterfaceName();
 472     }
 473
 474     static AllocatedRdsBuilder getRdsBuilder(String nexthop, String rd) {
 475         return new AllocatedRdsBuilder().withKey(new AllocatedRdsKey(nexthop)).setNexthop(nexthop).setRd(rd);
 476     }
 477
 478     public static Adjacencies getVpnInterfaceAugmentation(List<Adjacency> nextHopList) {
 479         return new AdjacenciesBuilder().setAdjacency(nextHopList).build();
 480     }
 481
 482     static AdjacenciesOp getVpnInterfaceOpDataEntryAugmentation(List<Adjacency> nextHopList) {
 483         return new AdjacenciesOpBuilder().setAdjacency(nextHopList).build();
 484     }
 485
 486     static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
 487         return InstanceIdentifier.builder(Interfaces.class).child(Interface.class,
 488                 new InterfaceKey(interfaceName)).build();
 489     }
 490
 491     public static BigInteger getCookieL3(int vpnId) {
 492         return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0610000", 16)).add(BigInteger.valueOf(vpnId));
 493     }
 494
 495     public int getUniqueId(String poolName, String idKey) {
 496         AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 497         try {
 498             Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
 499             RpcResult<AllocateIdOutput> rpcResult = result.get();
 500             if (rpcResult.isSuccessful()) {
 501                 return rpcResult.getResult().getIdValue().intValue();
 502             } else {
 503                 LOG.error("getUniqueId: RPC Call to Get Unique Id from pool {} with key {} returned with Errors {}",
 504                         poolName, idKey, rpcResult.getErrors());
 505             }
 506         } catch (InterruptedException | ExecutionException e) {
 507             LOG.error("getUniqueId: Exception when getting Unique Id from pool {} for key {}", poolName, idKey, e);
 508         }
 509         return 0;
 510     }
 511
 512     void releaseId(String poolName, String idKey) {
 513         ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
 514         try {
 515             RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
 516             if (!rpcResult.isSuccessful()) {
 517                 LOG.error("releaseId: RPC Call to release Id for key {} from pool {} returned with Errors {}",
 518                         idKey, poolName, rpcResult.getErrors());
 519             }
 520         } catch (InterruptedException | ExecutionException e) {
 521             LOG.error("releaseId: Exception when releasing Id for key {} from pool {}", idKey, poolName, e);
 522         }
 523     }
 524
 525     public static String getNextHopLabelKey(String rd, String prefix) {
 526         return rd + VpnConstants.SEPARATOR + prefix;
 527     }
 528
 529     /**
 530      * Retrieves the dataplane identifier of a specific VPN, searching by its
 531      * VpnInstance name.
 532      *
 533      * @param vpnName Name of the VPN
 534      * @return the dataplane identifier of the VPN, the VrfTag.
 535      */
 536     public long getVpnId(String vpnName) {
 537         if (vpnName == null) {
 538             return VpnConstants.INVALID_ID;
 539         }
 540
 541         return read(LogicalDatastoreType.CONFIGURATION, VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName))
 542                 .toJavaUtil().map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
 543                         .vpn.instance.to.vpn.id.VpnInstance::getVpnId).orElse(VpnConstants.INVALID_ID);
 544     }
 545
 546     /**
 547      * Retrieves the VPN Route Distinguisher searching by its Vpn instance name.
 548      *
 549      * @param vpnName Name of the VPN
 550      * @return the route-distinguisher of the VPN
 551      */
 552     public String getVpnRd(String vpnName) {
 553         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
 554             .VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION,
 555                 VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
 556         String rd = null;
 557         if (vpnInstance.isPresent()) {
 558             rd = vpnInstance.get().getVrfId();
 559         }
 560         return rd;
 561     }
 562
 563     List<String> getVpnRdsFromVpnInstanceConfig(String vpnName) {
 564         InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
 565             .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
 566         Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
 567         return vpnInstance.isPresent() ? getListOfRdsFromVpnInstance(vpnInstance.get()) : new ArrayList<>();
 568     }
 569
 570     /**
 571      * Remove from MDSAL all those VrfEntries in a VPN that have an specific RouteOrigin.
 572      *
 573      * @param rd Route Distinguisher
 574      * @param origin Origin of the Routes to be removed (see {@link RouteOrigin})
 575      */
 576     public void removeVrfEntriesByOrigin(String rd, RouteOrigin origin) {
 577         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 578             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 579         Optional<VrfTables> vrfTablesOpc = read(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
 580         if (vrfTablesOpc.isPresent()) {
 581             VrfTables vrfTables = vrfTablesOpc.get();
 582             ListenableFutures.addErrorLogging(
 583                     new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
 584                                                                             Datastore.CONFIGURATION, tx -> {
 585                             for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
 586                                 if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
 587                                     tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
 588                                 }
 589                             }
 590                         }), LOG, "Error removing VRF entries by origin");
 591         }
 592     }
 593
 594     public List<VrfEntry> findVrfEntriesByNexthop(String rd, String nexthop) {
 595         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 596             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 597         Optional<VrfTables> vrfTablesOpc = read(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
 598         List<VrfEntry> matches = new ArrayList<>();
 599         if (vrfTablesOpc.isPresent()) {
 600             VrfTables vrfTables = vrfTablesOpc.get();
 601             for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
 602                 vrfEntry.getRoutePaths().stream()
 603                         .filter(routePath -> routePath.getNexthopAddress() != null && routePath.getNexthopAddress()
 604                                 .equals(nexthop)).findFirst().ifPresent(routePath -> matches.add(vrfEntry));
 605             }
 606         }
 607         return matches;
 608     }
 609
 610     public void removeVrfEntries(String rd, List<VrfEntry> vrfEntries) {
 611         InstanceIdentifier<VrfTables> vpnVrfTableIid =
 612             InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
 613         ListenableFutures.addErrorLogging(
 614                 new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
 615                                                                             Datastore.CONFIGURATION, tx -> {
 616                         for (VrfEntry vrfEntry : vrfEntries) {
 617                             tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
 618                         }
 619                     }), LOG, "Error removing VRF entries");
 620     }
 621
 622     // TODO Clean up the exception handling
 623     @SuppressWarnings("checkstyle:IllegalCatch")
 624     public void withdrawRoutes(String rd, List<VrfEntry> vrfEntries) {
 625         vrfEntries.forEach(vrfEntry -> {
 626             try {
 627                 bgpManager.withdrawPrefix(rd, vrfEntry.getDestPrefix());
 628             } catch (Exception e) {
 629                 LOG.error("withdrawRoutes: Could not withdraw route to {} with route-paths {} in VpnRd {}",
 630                           vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths(), rd);
 631             }
 632         });
 633     }
 634
 635     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
 636         getVpnInstanceToVpnId(String vpnName, long vpnId, String rd) {
 637         return new VpnInstanceBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
 638
 639     }
 640
 641     static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
 642         getVpnIdToVpnInstance(long vpnId, String vpnName, String rd, boolean isExternalVpn) {
 643         return new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
 644             .VpnIdsBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).setExternalVpn(isExternalVpn)
 645                 .build();
 646
 647     }
 648
 649     static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to
 650         .vpn.instance.VpnIds> getVpnIdToVpnInstanceIdentifier(long vpnId) {
 651         return InstanceIdentifier.builder(VpnIdToVpnInstance.class).child(org.opendaylight.yang.gen.v1.urn
 652                 .opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds.class,
 653                 new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
 654                     .VpnIdsKey(vpnId)).build();
 655     }
 656
 657     /**
 658      * Retrieves the Vpn Name searching by its VPN Tag.
 659      *
 660      * @param vpnId Dataplane identifier of the VPN
 661      * @return the Vpn instance name
 662      */
 663     String getVpnName(long vpnId) {
 664
 665         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
 666             .instance.VpnIds> id = getVpnIdToVpnInstanceIdentifier(vpnId);
 667         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
 668             vpnInstance
 669             = read(LogicalDatastoreType.CONFIGURATION, id);
 670         String vpnName = null;
 671         if (vpnInstance.isPresent()) {
 672             vpnName = vpnInstance.get().getVpnInstanceName();
 673         }
 674         return vpnName;
 675     }
 676
 677     public static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
 678         return InstanceIdentifier.builder(VpnInstanceOpData.class)
 679             .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
 680     }
 681
 682     public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd) {
 683         InstanceIdentifier<VpnInstanceOpDataEntry> id = getVpnInstanceOpDataIdentifier(rd);
 684         return read(LogicalDatastoreType.OPERATIONAL, id).orNull();
 685     }
 686
 687     VpnInterface getConfiguredVpnInterface(String interfaceName) {
 688         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 689         Optional<VpnInterface> configuredVpnInterface = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
 690         if (configuredVpnInterface.isPresent()) {
 691             return configuredVpnInterface.get();
 692         }
 693         return null;
 694     }
 695
 696     boolean isVpnInterfaceConfigured(String interfaceName) {
 697         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 698         return read(LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent();
 699     }
 700
 701     public Optional<List<String>> getVpnHandlingIpv4AssociatedWithInterface(String interfaceName) {
 702         InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
 703         Optional<List<String>> vpnOptional = Optional.absent();
 704         Optional<VpnInterface> optConfiguredVpnInterface = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
 705         if (optConfiguredVpnInterface.isPresent()) {
 706             VpnInterface cfgVpnInterface = optConfiguredVpnInterface.get();
 707             java.util.Optional<List<VpnInstanceNames>> optVpnInstanceList =
 708                  java.util.Optional.ofNullable(cfgVpnInterface.getVpnInstanceNames());
 709             if (optVpnInstanceList.isPresent()) {
 710                 List<String> vpnList = new ArrayList<>();
 711                 for (VpnInstanceNames vpnInstance : optVpnInstanceList.get()) {
 712                     vpnList.add(vpnInstance.getVpnName());
 713                 }
 714                 vpnOptional = Optional.of(vpnList);
 715             }
 716         }
 717         return vpnOptional;
 718     }
 719
 720     public static String getIpPrefix(String prefix) {
 721         String[] prefixValues = prefix.split("/");
 722         if (prefixValues.length == 1) {
 723             prefix = NWUtil.toIpPrefix(prefix);
 724         }
 725         return prefix;
 726     }
 727
 728     static final FutureCallback<Void> DEFAULT_CALLBACK =
 729         new FutureCallback<Void>() {
 730             @Override
 731             public void onSuccess(Void result) {
 732                 LOG.debug("Success in Datastore operation");
 733             }
 734
 735             @Override
 736             public void onFailure(Throwable error) {
 737                 LOG.error("Error in Datastore operation", error);
 738             }
 739
 740         };
 741
 742     @Deprecated
 743     private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
 744         try {
 745             return SingleTransactionDataBroker.syncReadOptional(dataBroker, datastoreType, path);
 746         } catch (ReadFailedException e) {
 747             throw new RuntimeException(e);
 748         }
 749     }
 750
 751     @Deprecated
 752     public <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path,
 753                                                  T data) {
 754         try {
 755             SingleTransactionDataBroker.syncWrite(dataBroker, datastoreType, path, data);
 756         } catch (TransactionCommitFailedException e) {
 757             LOG.error("syncWrite: Error writing to datastore (path, data) : ({}, {})", path, data, e);
 758             throw new RuntimeException(e.getMessage(), e);
 759         }
 760     }
 761
 762     @Deprecated
 763     public <T extends DataObject> void syncUpdate(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path,
 764                                                   T data) {
 765         try {
 766             SingleTransactionDataBroker.syncUpdate(dataBroker, datastoreType, path, data);
 767         } catch (TransactionCommitFailedException e) {
 768             LOG.error("syncUpdate: Error writing to datastore (path, data) : ({}, {})", path, data, e);
 769             throw new RuntimeException(e.getMessage(), e);
 770         }
 771     }
 772
 773     static long getRemoteBCGroup(long elanTag) {
 774         return VpnConstants.ELAN_GID_MIN + elanTag % VpnConstants.ELAN_GID_MIN * 2;
 775     }
 776
 777     // interface-index-tag operational container
 778     IfIndexInterface getInterfaceInfoByInterfaceTag(long interfaceTag) {
 779         InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
 780         Optional<IfIndexInterface> existingInterfaceInfo = read(LogicalDatastoreType.OPERATIONAL, interfaceId);
 781         if (existingInterfaceInfo.isPresent()) {
 782             return existingInterfaceInfo.get();
 783         }
 784         return null;
 785     }
 786
 787     static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
 788         return InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class,
 789             new IfIndexInterfaceKey((int) interfaceTag)).build();
 790     }
 791
 792     ElanTagName getElanInfoByElanTag(long elanTag) {
 793         InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
 794         Optional<ElanTagName> existingElanInfo = read(LogicalDatastoreType.OPERATIONAL, elanId);
 795         if (existingElanInfo.isPresent()) {
 796             return existingElanInfo.get();
 797         }
 798         return null;
 799     }
 800
 801     static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
 802         return InstanceIdentifier.builder(ElanTagNameMap.class).child(ElanTagName.class,
 803             new ElanTagNameKey(elanTag)).build();
 804     }
 805
 806     static void removePrefixToInterfaceForVpnId(long vpnId,
 807                                                        @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
 808         // Clean up PrefixToInterface Operational DS
 809         operTx.delete(InstanceIdentifier.builder(
 810                     PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build());
 811     }
 812
 813     static void removeVpnExtraRouteForVpn(String vpnName,
 814                                                     @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
 815         // Clean up VPNExtraRoutes Operational DS
 816         operTx.delete(InstanceIdentifier.builder(VpnToExtraroutes.class).child(Vpn.class, new VpnKey(vpnName)).build());
 817     }
 818
 819     // TODO Clean up the exception handling
 820     @SuppressWarnings("checkstyle:IllegalCatch")
 821     static void removeVpnOpInstance(String vpnName,
 822                                                     @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
 823         // Clean up VPNInstanceOpDataEntry
 824         operTx.delete(getVpnInstanceOpDataIdentifier(vpnName));
 825     }
 826
 827     static void removeVpnInstanceToVpnId(String vpnName,
 828                                                 @Nonnull TypedWriteTransaction<Datastore.Configuration> confTx) {
 829         confTx.delete(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
 830     }
 831
 832     static void removeVpnIdToVpnInstance(long vpnId,
 833                                                 @Nonnull TypedWriteTransaction<Datastore.Configuration> confTx) {
 834         confTx.delete(getVpnIdToVpnInstanceIdentifier(vpnId));
 835     }
 836
 837     static void removeL3nexthopForVpnId(long vpnId,
 838                                                @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
 839         // Clean up L3NextHop Operational DS
 840         operTx.delete(InstanceIdentifier.builder(L3nexthop.class).child(
 841                                     VpnNexthops.class, new VpnNexthopsKey(vpnId)).build());
 842     }
 843
 844     void scheduleVpnInterfaceForRemoval(String interfaceName, BigInteger dpnId,
 845                                                       String vpnInstanceName, Boolean isScheduledToRemove,
 846                                                       TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
 847         InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
 848                 getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnInstanceName);
 849         VpnInterfaceOpDataEntry interfaceToUpdate =
 850             new VpnInterfaceOpDataEntryBuilder().withKey(new VpnInterfaceOpDataEntryKey(interfaceName,
 851             vpnInstanceName)).setName(interfaceName).setDpnId(dpnId).setVpnInstanceName(vpnInstanceName)
 852             .setScheduledForRemove(isScheduledToRemove).build();
 853         if (writeOperTxn != null) {
 854             writeOperTxn.merge(interfaceId, interfaceToUpdate, true);
 855         } else {
 856             syncUpdate(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate);
 857         }
 858     }
 859
 860     void createLearntVpnVipToPort(String vpnName, String fixedIp, String
 861             portName, String macAddress, TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
 862         synchronized ((vpnName + fixedIp).intern()) {
 863             InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
 864             LearntVpnVipToPortBuilder builder =
 865                     new LearntVpnVipToPortBuilder().withKey(new LearntVpnVipToPortKey(fixedIp, vpnName)).setVpnName(
 866                             vpnName).setPortFixedip(fixedIp).setPortName(portName)
 867                             .setMacAddress(macAddress.toLowerCase(Locale.getDefault()))
 868                             .setCreationTime(new SimpleDateFormat("MM/dd/yyyy h:mm:ss a").format(new Date()));
 869             if (writeOperTxn != null) {
 870                 writeOperTxn.put(id, builder.build(), true);
 871             } else {
 872                 syncWrite(LogicalDatastoreType.OPERATIONAL, id, builder.build());
 873             }
 874             LOG.debug("createLearntVpnVipToPort: ARP/NA learned for fixedIp: {}, vpn {}, interface {}, mac {},"
 875                     + " added to LearntVpnVipToPort DS", fixedIp, vpnName, portName, macAddress);
 876         }
 877     }
 878
 879     static InstanceIdentifier<LearntVpnVipToPort> buildLearntVpnVipToPortIdentifier(String vpnName,
 880             String fixedIp) {
 881         return InstanceIdentifier.builder(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class,
 882                 new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
 883     }
 884
 885     void removeLearntVpnVipToPort(String vpnName, String fixedIp,
 886                                                    TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
 887         synchronized ((vpnName + fixedIp).intern()) {
 888             InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
 889             if (writeOperTxn != null) {
 890                 writeOperTxn.delete(id);
 891             } else {
 892                 MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
 893             }
 894             LOG.debug("removeLearntVpnVipToPort: Deleted LearntVpnVipToPort entry for fixedIp: {}, vpn {}",
 895                 fixedIp, vpnName);
 896         }
 897     }
 898
 899     protected static void removeVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp,
 900                                                      TypedWriteTransaction<Datastore.Configuration> writeConfigTxn) {
 901         synchronized ((vpnName + fixedIp).intern()) {
 902             InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
 903             if (writeConfigTxn != null) {
 904                 writeConfigTxn.delete(id);
 905             } else {
 906                 MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, id);
 907             }
 908             LOG.debug("removeVpnPortFixedIpToPort: Deleted VpnPortipToPort entry for fixedIp: {}, vpn {}",
 909                 fixedIp, vpnName);
 910         }
 911     }
 912
 913     public void createLearntVpnVipToPortEvent(String vpnName, String srcIp, String destIP, String portName,
 914                                               String macAddress, LearntVpnVipToPortEventAction action,
 915                                               TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
 916         String eventId = MicroTimestamp.INSTANCE.get();
 917
 918         InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
 919         LearntVpnVipToPortEventBuilder builder = new LearntVpnVipToPortEventBuilder().withKey(
 920                 new LearntVpnVipToPortEventKey(eventId)).setVpnName(vpnName).setSrcFixedip(srcIp)
 921                 .setDestFixedip(destIP).setPortName(portName)
 922                 .setMacAddress(macAddress.toLowerCase(Locale.getDefault())).setEventAction(action);
 923         if (writeOperTxn != null) {
 924             writeOperTxn.delete(id);
 925         } else {
 926             syncWrite(LogicalDatastoreType.OPERATIONAL, id, builder.build());
 927         }
 928         LOG.info("createLearntVpnVipToPortEvent: ARP learn event created for fixedIp: {}, vpn {}, interface {},"
 929                 + " mac {} action {} eventId {}", srcIp, vpnName, portName, macAddress, action, eventId);
 930     }
 931
 932     private static InstanceIdentifier<LearntVpnVipToPortEvent> buildLearntVpnVipToPortEventIdentifier(String eventId) {
 933         InstanceIdentifier<LearntVpnVipToPortEvent> id = InstanceIdentifier.builder(LearntVpnVipToPortEventData.class)
 934                 .child(LearntVpnVipToPortEvent.class, new LearntVpnVipToPortEventKey(eventId)).build();
 935         return id;
 936     }
 937
 938     void removeLearntVpnVipToPortEvent(String eventId, TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
 939         InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
 940         if (writeOperTxn != null) {
 941             writeOperTxn.delete(id);
 942         } else {
 943             MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
 944         }
 945         LOG.info("removeLearntVpnVipToPortEvent: Deleted Event {}", eventId);
 946
 947     }
 948
 949     void removeMipAdjAndLearntIp(String vpnName, String vpnInterface, String prefix) {
 950         synchronized ((vpnName + prefix).intern()) {
 951             InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, prefix);
 952             MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
 953             LOG.info("removeMipAdjAndLearntIp: Delete learned ARP for fixedIp: {}, vpn {} removed from"
 954                             + "VpnPortipToPort DS", prefix, vpnName);
 955             String ip = VpnUtil.getIpPrefix(prefix);
 956             InstanceIdentifier<VpnInterfaceOpDataEntry> vpnInterfaceOpId = VpnUtil
 957                     .getVpnInterfaceOpDataEntryIdentifier(vpnInterface, vpnName);
 958             InstanceIdentifier<AdjacenciesOp> path = vpnInterfaceOpId.augmentation(AdjacenciesOp.class);
 959             Optional<AdjacenciesOp> adjacenciesOp = read(LogicalDatastoreType.OPERATIONAL, path);
 960             if (adjacenciesOp.isPresent()) {
 961                 InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class)
 962                         .child(VpnInterface.class, new VpnInterfaceKey(vpnInterface)).augmentation(Adjacencies.class)
 963                         .child(Adjacency.class, new AdjacencyKey(ip)).build();
 964                 MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
 965                 LOG.info("removeMipAdjAndLearntIp: Successfully Deleted Adjacency {} from interface {} vpn {}", ip,
 966                         vpnInterface, vpnName);
 967             }
 968         }
 969     }
 970
 971     static InstanceIdentifier<NetworkMap> buildNetworkMapIdentifier(Uuid networkId) {
 972         return InstanceIdentifier.builder(NetworkMaps.class).child(NetworkMap.class, new
 973                 NetworkMapKey(networkId)).build();
 974     }
 975
 976     static InstanceIdentifier<SubnetOpDataEntry> buildSubnetOpDataEntryInstanceIdentifier(Uuid subnetId) {
 977         return InstanceIdentifier.builder(SubnetOpData.class)
 978                 .child(SubnetOpDataEntry.class, new SubnetOpDataEntryKey(subnetId)).build();
 979     }
 980
 981     static InstanceIdentifier<VpnPortipToPort> buildVpnPortipToPortIdentifier(String vpnName, String fixedIp) {
 982         return InstanceIdentifier.builder(NeutronVpnPortipPortData.class).child(VpnPortipToPort.class,
 983                 new VpnPortipToPortKey(fixedIp, vpnName)).build();
 984     }
 985
 986     public VpnPortipToPort getNeutronPortFromVpnPortFixedIp(String vpnName, String fixedIp) {
 987         InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
 988         Optional<VpnPortipToPort> vpnPortipToPortData = read(LogicalDatastoreType.CONFIGURATION, id);
 989         if (vpnPortipToPortData.isPresent()) {
 990             return vpnPortipToPortData.get();
 991         }
 992         return null;
 993     }
 994
 995     public LearntVpnVipToPort getLearntVpnVipToPort(String vpnName, String fixedIp) {
 996         InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
 997         Optional<LearntVpnVipToPort> learntVpnVipToPort = read(LogicalDatastoreType.OPERATIONAL, id);
 998         if (learntVpnVipToPort.isPresent()) {
 999             return learntVpnVipToPort.get();
1000         }
1001         return null;
1002     }
1003
1004     @Nonnull
1005     List<BigInteger> getDpnsOnVpn(String vpnInstanceName) {
1006         List<BigInteger> result = new ArrayList<>();
1007         String rd = getVpnRd(vpnInstanceName);
1008         if (rd == null) {
1009             LOG.debug("getDpnsOnVpn: Could not find Route-Distinguisher for VpnName={}", vpnInstanceName);
1010             return result;
1011         }
1012         VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
1013         if (vpnInstanceOpData == null) {
1014             LOG.debug("getDpnsOnVpn: Could not find OpState for VpnName={}", vpnInstanceName);
1015             return result;
1016         }
1017         List<VpnToDpnList> vpnToDpnList = vpnInstanceOpData.getVpnToDpnList();
1018         if (vpnToDpnList == null) {
1019             LOG.debug("getDpnsOnVpn: Could not find DPN footprint for VpnName={}", vpnInstanceName);
1020             return result;
1021         }
1022         for (VpnToDpnList vpnToDpn : vpnToDpnList) {
1023             result.add(vpnToDpn.getDpnId());
1024         }
1025         return result;
1026     }
1027
1028     String getAssociatedExternalRouter(String extIp) {
1029         InstanceIdentifier<ExtRouters> extRouterInstanceIndentifier =
1030                 InstanceIdentifier.builder(ExtRouters.class).build();
1031         Optional<ExtRouters> extRouterData = read(LogicalDatastoreType.CONFIGURATION, extRouterInstanceIndentifier);
1032         if (extRouterData.isPresent()) {
1033             for (Routers routerData : extRouterData.get().getRouters()) {
1034                 List<ExternalIps> externalIps = routerData.getExternalIps();
1035                 for (ExternalIps externalIp : externalIps) {
1036                     if (externalIp.getIpAddress().equals(extIp)) {
1037                         return routerData.getRouterName();
1038                     }
1039                 }
1040             }
1041         }
1042         return null;
1043     }
1044
1045     static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
1046         return InstanceIdentifier.builder(ExtRouters.class).child(Routers.class, new RoutersKey(routerId)).build();
1047     }
1048
1049     Networks getExternalNetwork(Uuid networkId) {
1050         InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
1051             .child(Networks.class, new NetworksKey(networkId)).build();
1052         Optional<Networks> optionalNets = read(LogicalDatastoreType.CONFIGURATION, netsIdentifier);
1053         return optionalNets.isPresent() ? optionalNets.get() : null;
1054     }
1055
1056     Uuid getExternalNetworkVpnId(Uuid networkId) {
1057         Networks extNetwork = getExternalNetwork(networkId);
1058         return extNetwork != null ? extNetwork.getVpnid() : null;
1059     }
1060
1061     List<Uuid> getExternalNetworkRouterIds(Uuid networkId) {
1062         Networks extNetwork = getExternalNetwork(networkId);
1063         return extNetwork != null ? extNetwork.getRouterIds() : Collections.emptyList();
1064     }
1065
1066     Routers getExternalRouter(String routerId) {
1067         InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class).child(Routers.class,
1068                 new RoutersKey(routerId)).build();
1069         Optional<Routers> routerData = read(LogicalDatastoreType.CONFIGURATION, id);
1070         return routerData.isPresent() ? routerData.get() : null;
1071     }
1072
1073     static InstanceIdentifier<Subnetmaps> buildSubnetMapsWildCardPath() {
1074         return InstanceIdentifier.create(Subnetmaps.class);
1075     }
1076
1077     FlowEntity buildL3vpnGatewayFlow(BigInteger dpId, String gwMacAddress, long vpnId,
1078                                                    long subnetVpnId) {
1079         List<MatchInfo> mkMatches = new ArrayList<>();
1080         Subnetmap smap = null;
1081         mkMatches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnId), MetaDataUtil.METADATA_MASK_VRFID));
1082         mkMatches.add(new MatchEthernetDestination(new MacAddress(gwMacAddress)));
1083         List<InstructionInfo> mkInstructions = new ArrayList<>();
1084         mkInstructions.add(new InstructionGotoTable(NwConstants.L3_FIB_TABLE));
1085         if (subnetVpnId != VpnConstants.INVALID_ID) {
1086             String vpnName = getVpnName(subnetVpnId);
1087             if (vpnName != null) {
1088                 smap = getSubnetmapFromItsUuid(Uuid.getDefaultInstance(vpnName));
1089                 if (smap != null && smap.getSubnetIp() != null) {
1090                     IpVersionChoice ipVersionChoice = getIpVersionFromString(smap.getSubnetIp());
1091                     if (ipVersionChoice == IpVersionChoice.IPV4) {
1092                         mkMatches.add(MatchEthernetType.IPV4);
1093                     } else {
1094                         mkMatches.add(MatchEthernetType.IPV6);
1095                     }
1096                 }
1097             }
1098             BigInteger subnetIdMetaData = MetaDataUtil.getVpnIdMetadata(subnetVpnId);
1099             mkInstructions.add(new InstructionWriteMetadata(subnetIdMetaData, MetaDataUtil.METADATA_MASK_VRFID));
1100         }
1101         String flowId = getL3VpnGatewayFlowRef(NwConstants.L3_GW_MAC_TABLE, dpId, vpnId, gwMacAddress, subnetVpnId);
1102         return MDSALUtil.buildFlowEntity(dpId, NwConstants.L3_GW_MAC_TABLE,
1103                 flowId, 20, flowId, 0, 0, NwConstants.COOKIE_L3_GW_MAC_TABLE, mkMatches, mkInstructions);
1104     }
1105
1106     static String getL3VpnGatewayFlowRef(short l3GwMacTable, BigInteger dpId, long vpnId, String gwMacAddress,
1107                                          long subnetVpnId) {
1108         return gwMacAddress + NwConstants.FLOWID_SEPARATOR + vpnId + NwConstants.FLOWID_SEPARATOR + dpId
1109             + NwConstants.FLOWID_SEPARATOR + l3GwMacTable + NwConstants.FLOWID_SEPARATOR + subnetVpnId;
1110     }
1111
1112     void lockSubnet(String subnetId) {
1113         TryLockInput input =
1114             new TryLockInputBuilder().setLockName(subnetId).setTime(3000L).setTimeUnit(TimeUnits.Milliseconds).build();
1115         Future<RpcResult<TryLockOutput>> result = lockManager.tryLock(input);
1116         try {
1117             if (result != null && result.get().isSuccessful()) {
1118                 LOG.debug("lockSubnet: Acquired lock for {}", subnetId);
1119             } else {
1120                 LOG.error("Unable to get lock for subnet {}", subnetId);
1121                 throw new RuntimeException("Unable to get lock for subnet " + subnetId);
1122             }
1123         } catch (InterruptedException | ExecutionException e) {
1124             LOG.error("Unable to get lock for subnet {}", subnetId, e);
1125             throw new RuntimeException("Unable to get lock for subnet " + subnetId, e);
1126         }
1127     }
1128
1129     // We store the cause, which is what we really care about
1130     @SuppressWarnings("checkstyle:AvoidHidingCauseException")
1131     public void unlockSubnet(String subnetId) {
1132         UnlockInput input = new UnlockInputBuilder().setLockName(subnetId).build();
1133         Future<RpcResult<UnlockOutput>> result = lockManager.unlock(input);
1134         try {
1135             if (result != null && result.get().isSuccessful()) {
1136                 LOG.debug("unlockSubnet: Unlocked {}", subnetId);
1137             } else {
1138                 LOG.debug("unlockSubnet: Unable to unlock subnet {}", subnetId);
1139             }
1140         } catch (InterruptedException | ExecutionException e) {
1141             LOG.error("unlockSubnet: Unable to unlock subnet {}", subnetId);
1142             throw new RuntimeException(String.format("Unable to unlock subnetId %s", subnetId), e.getCause());
1143         }
1144     }
1145
1146     Optional<IpAddress> getIpv4GatewayAddressFromInterface(String srcInterface) {
1147         Optional<IpAddress> gatewayIp = Optional.absent();
1148         if (neutronVpnService != null) {
1149             //TODO(Gobinath): Need to fix this as assuming port will belong to only one Subnet would be incorrect"
1150             Port port = neutronVpnService.getNeutronPort(srcInterface);
1151             if (port != null && port.getFixedIps() != null) {
1152                 for (FixedIps portIp: port.getFixedIps()) {
1153                     if (portIp.getIpAddress().getIpv6Address() != null) {
1154                         // Skip IPv6 address
1155                         continue;
1156                     }
1157                     gatewayIp = Optional.of(
1158                             neutronVpnService.getNeutronSubnet(portIp.getSubnetId()).getGatewayIp());
1159                 }
1160             }
1161         } else {
1162             LOG.error("getGatewayIpAddressFromInterface: neutron vpn service is not configured."
1163                     + " Failed for interface {}.", srcInterface);
1164         }
1165         return gatewayIp;
1166     }
1167
1168     Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp) {
1169         Optional<String> gatewayMac = Optional.absent();
1170         long vpnId = getVpnId(macEntry.getVpnName());
1171         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
1172             .instance.VpnIds>
1173             vpnIdsInstanceIdentifier = VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId);
1174         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
1175             vpnIdsOptional = read(LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
1176         if (!vpnIdsOptional.isPresent()) {
1177             LOG.error("getGWMacAddressFromInterface: VPN {} not configured", vpnId);
1178             return gatewayMac;
1179         }
1180         VpnPortipToPort vpnTargetIpToPort = getNeutronPortFromVpnPortFixedIp(macEntry.getVpnName(),
1181                 gatewayIp.getIpv4Address().getValue());
1182         if (vpnTargetIpToPort != null && vpnTargetIpToPort.isSubnetIp()) {
1183             gatewayMac = Optional.of(vpnTargetIpToPort.getMacAddress());
1184         } else {
1185             org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
1186                     .vpn.id.to.vpn.instance.VpnIds vpnIds = vpnIdsOptional.get();
1187             if (vpnIds.isExternalVpn()) {
1188                 gatewayMac = InterfaceUtils.getMacAddressForInterface(dataBroker, macEntry.getInterfaceName());
1189             }
1190         }
1191         return gatewayMac;
1192     }
1193
1194     void setupGwMacIfExternalVpn(BigInteger dpnId, String interfaceName, long vpnId, WriteTransaction writeInvTxn,
1195                                  int addOrRemove, String gwMac) {
1196         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
1197             .VpnIds> vpnIdsInstanceIdentifier = getVpnIdToVpnInstanceIdentifier(vpnId);
1198         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
1199             .VpnIds> vpnIdsOptional = read(LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
1200         if (vpnIdsOptional.isPresent() && vpnIdsOptional.get().isExternalVpn()) {
1201             if (gwMac == null) {
1202                 LOG.error("setupGwMacIfExternalVpn: Failed to get gwMacAddress for interface {} on dpn {} vpn {}",
1203                         interfaceName, dpnId.toString(), vpnIdsOptional.get().getVpnInstanceName());
1204                 return;
1205             }
1206             FlowEntity flowEntity = buildL3vpnGatewayFlow(dpnId, gwMac, vpnId, VpnConstants.INVALID_ID);
1207             if (addOrRemove == NwConstants.ADD_FLOW) {
1208                 mdsalManager.addFlowToTx(flowEntity, writeInvTxn);
1209             } else if (addOrRemove == NwConstants.DEL_FLOW) {
1210                 mdsalManager.removeFlowToTx(flowEntity, writeInvTxn);
1211             }
1212         }
1213     }
1214
1215     public Optional<String> getVpnSubnetGatewayIp(final Uuid subnetUuid) {
1216         Optional<String> gwIpAddress = Optional.absent();
1217         final SubnetKey subnetkey = new SubnetKey(subnetUuid);
1218         final InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class)
1219                 .child(Subnets.class)
1220                 .child(Subnet.class, subnetkey);
1221         final Optional<Subnet> subnet = read(LogicalDatastoreType.CONFIGURATION, subnetidentifier);
1222         if (subnet.isPresent()) {
1223             Class<? extends IpVersionBase> ipVersionBase = subnet.get().getIpVersion();
1224             if (ipVersionBase.equals(IpVersionV4.class)) {
1225                 Subnetmap subnetmap = getSubnetmapFromItsUuid(subnetUuid);
1226                 if (subnetmap != null && subnetmap.getRouterInterfaceFixedIp() != null) {
1227                     LOG.trace("getVpnSubnetGatewayIp: Obtained subnetMap {} for vpn interface",
1228                             subnetmap.getId().getValue());
1229                     gwIpAddress = Optional.of(subnetmap.getRouterInterfaceFixedIp());
1230                 } else {
1231                     //For direct L3VPN to network association (no router) continue to use subnet-gateway IP
1232                     IpAddress gwIp = subnet.get().getGatewayIp();
1233                     if (gwIp != null && gwIp.getIpv4Address() != null) {
1234                         gwIpAddress = Optional.of(gwIp.getIpv4Address().getValue());
1235                     }
1236                 }
1237                 LOG.trace("getVpnSubnetGatewayIp: Obtained subnet-gw ip {} for vpn interface",
1238                         gwIpAddress.get());
1239             }
1240         }
1241         return gwIpAddress;
1242     }
1243
1244     RouterToNaptSwitch getRouterToNaptSwitch(String routerName) {
1245         InstanceIdentifier<RouterToNaptSwitch> id = InstanceIdentifier.builder(NaptSwitches.class)
1246                 .child(RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerName)).build();
1247         Optional<RouterToNaptSwitch> routerToNaptSwitchData = read(LogicalDatastoreType.CONFIGURATION, id);
1248         return routerToNaptSwitchData.isPresent() ? routerToNaptSwitchData.get() : null;
1249     }
1250
1251     static InstanceIdentifier<Subnetmap> buildSubnetmapIdentifier(Uuid subnetId) {
1252         return InstanceIdentifier.builder(Subnetmaps.class)
1253         .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
1254
1255     }
1256
1257     BigInteger getPrimarySwitchForRouter(String routerName) {
1258         RouterToNaptSwitch routerToNaptSwitch = getRouterToNaptSwitch(routerName);
1259         return routerToNaptSwitch != null ? routerToNaptSwitch.getPrimarySwitchId() : null;
1260     }
1261
1262     static boolean isL3VpnOverVxLan(Long l3Vni) {
1263         return l3Vni != null && l3Vni != 0;
1264     }
1265
1266     /**
1267      * Retrieves the primary rd of a vpn instance
1268      * Primary rd will be the first rd in the list of rds configured for a vpn instance
1269      * If rd list is empty, primary rd will be vpn instance name
1270      * Use this function only during create operation cycles. For other operations, use getVpnRd() method.
1271      *
1272      * @param vpnName Name of the VPN
1273      * @return the primary rd of the VPN
1274      */
1275     public String getPrimaryRd(String vpnName) {
1276         // Retrieves the VPN Route Distinguisher by its Vpn instance name
1277         String rd = getVpnRd(vpnName);
1278         if (rd != null) {
1279             return rd;
1280         }
1281         InstanceIdentifier<VpnInstance> id  = getVpnInstanceIdentifier(vpnName);
1282         Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
1283         if (vpnInstance.isPresent()) {
1284             return getPrimaryRd(vpnInstance.get());
1285         }
1286         return vpnName;
1287     }
1288
1289     /**
1290      * Retrieves the primary rd of a vpn instance
1291      * Primary rd will be the first rd in the list of rds configured for a vpn instance
1292      * If rd list is empty, primary rd will be vpn instance name
1293      * Use this function only during create operation cycles. For other operations, use getVpnRd() method.
1294      *
1295      * @param vpnInstance Config Vpn Instance Object
1296      * @return the primary rd of the VPN
1297      */
1298     static String getPrimaryRd(VpnInstance vpnInstance) {
1299         List<String> rds = null;
1300         if (vpnInstance != null) {
1301             rds = getListOfRdsFromVpnInstance(vpnInstance);
1302         }
1303         return rds == null || rds.isEmpty() ? vpnInstance.getVpnInstanceName() : rds.get(0);
1304     }
1305
1306     static boolean isBgpVpn(String vpnName, String primaryRd) {
1307         return !vpnName.equals(primaryRd);
1308     }
1309
1310     java.util.Optional<String> allocateRdForExtraRouteAndUpdateUsedRdsMap(long vpnId, @Nullable Long parentVpnId,
1311                                                                           String prefix, String vpnName,
1312                                                                           String nextHop, BigInteger dpnId) {
1313         //Check if rd is already allocated for this extraroute behind the same VM. If yes, reuse it.
1314         //This is particularly useful during reboot scenarios.
1315         java.util.Optional<String> allocatedRd = VpnExtraRouteHelper
1316                 .getRdAllocatedForExtraRoute(dataBroker, vpnId, prefix, nextHop);
1317         if (allocatedRd.isPresent()) {
1318             return allocatedRd;
1319         }
1320
1321         //Check if rd is already allocated for this extraroute behind the same CSS. If yes, reuse it
1322         List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker, vpnId, prefix);
1323         for (String usedRd : usedRds) {
1324             Optional<Routes> vpnExtraRoutes = VpnExtraRouteHelper.getVpnExtraroutes(dataBroker,
1325                     vpnName, usedRd, prefix);
1326             if (vpnExtraRoutes.isPresent()) {
1327                 String nextHopIp = vpnExtraRoutes.get().getNexthopIpList().get(0);
1328                 // In case of VPN importing the routes, the interface is not present in the VPN
1329                 // and has to be fetched from the VPN from which it imports
1330                 Optional<Prefixes> prefixToInterface =
1331                         getPrefixToInterface(parentVpnId != null ? parentVpnId : vpnId, nextHopIp);
1332                 if (prefixToInterface.isPresent() && dpnId.equals(prefixToInterface.get().getDpnId())) {
1333                     syncUpdate(LogicalDatastoreType.CONFIGURATION,
1334                             VpnExtraRouteHelper.getUsedRdsIdentifier(vpnId, prefix, nextHop),
1335                             getRdsBuilder(nextHop, usedRd).build());
1336                     return java.util.Optional.of(usedRd);
1337                 }
1338             }
1339         }
1340         List<String> availableRds = getVpnRdsFromVpnInstanceConfig(vpnName);
1341         String rd;
1342         if (availableRds.isEmpty()) {
1343             rd = dpnId.toString();
1344             LOG.debug("Internal vpn {} Returning DpnId {} as rd", vpnName, rd);
1345         } else {
1346             LOG.trace("Removing used rds {} from available rds {} vpnid {} . prefix is {} , vpname- {}, dpnId- {}",
1347                     usedRds, availableRds, vpnId, prefix, vpnName, dpnId);
1348             availableRds.removeAll(usedRds);
1349             if (availableRds.isEmpty()) {
1350                 LOG.error("No rd available from VpnInstance to allocate for prefix {}", prefix);
1351                 return java.util.Optional.empty();
1352             }
1353             // If rd is not allocated for this prefix or if extra route is behind different OVS, select a new rd.
1354             rd = availableRds.get(0);
1355         }
1356         syncUpdate(LogicalDatastoreType.CONFIGURATION,
1357                 VpnExtraRouteHelper.getUsedRdsIdentifier(vpnId, prefix, nextHop), getRdsBuilder(nextHop, rd).build());
1358         return java.util.Optional.ofNullable(rd);
1359     }
1360
1361     static String getVpnNamePrefixKey(String vpnName, String prefix) {
1362         return vpnName + VpnConstants.SEPARATOR + prefix;
1363     }
1364
1365     static InstanceIdentifier<Adjacency> getAdjacencyIdentifier(String vpnInterfaceName, String ipAddress) {
1366         return InstanceIdentifier.builder(VpnInterfaces.class)
1367                 .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName))
1368                 .augmentation(Adjacencies.class).child(Adjacency.class, new AdjacencyKey(ipAddress)).build();
1369     }
1370
1371     public static List<String> getIpsListFromExternalIps(List<ExternalIps> externalIps) {
1372         if (externalIps == null) {
1373             return Collections.emptyList();
1374         }
1375
1376         return externalIps.stream().map(ExternalIps::getIpAddress).collect(Collectors.toList());
1377     }
1378
1379     void bindService(final String vpnInstanceName, final String interfaceName, boolean isTunnelInterface) {
1380         jobCoordinator.enqueueJob(interfaceName,
1381             () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(
1382                                                                                 Datastore.CONFIGURATION, tx -> {
1383                     BoundServices serviceInfo = isTunnelInterface
1384                             ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
1385                             : getBoundServicesForVpnInterface(vpnInstanceName, interfaceName);
1386                     tx.put(InterfaceUtils.buildServiceId(interfaceName,
1387                             ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
1388                                     NwConstants.L3VPN_SERVICE_INDEX)),
1389                             serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
1390                 })), SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
1391     }
1392
1393     BoundServices getBoundServicesForVpnInterface(String vpnName, String interfaceName) {
1394         List<Instruction> instructions = new ArrayList<>();
1395         int instructionKey = 0;
1396         final long vpnId = getVpnId(vpnName);
1397         List<Action> actions = Collections.singletonList(
1398                 new ActionRegLoad(0, VpnConstants.VPN_REG_ID, 0, VpnConstants.VPN_ID_LENGTH, vpnId).buildAction());
1399         instructions.add(MDSALUtil.buildApplyActionsInstruction(actions, ++instructionKey));
1400         instructions.add(
1401                 MDSALUtil.buildAndGetWriteMetadaInstruction(MetaDataUtil.getVpnIdMetadata(vpnId),
1402                         MetaDataUtil.METADATA_MASK_VRFID, ++instructionKey));
1403         instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.L3_GW_MAC_TABLE,
1404                 ++instructionKey));
1405         BoundServices serviceInfo = InterfaceUtils.getBoundServices(
1406                 String.format("%s.%s.%s", "vpn", vpnName, interfaceName),
1407                 ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME, NwConstants.L3VPN_SERVICE_INDEX),
1408                 VpnConstants.DEFAULT_FLOW_PRIORITY, NwConstants.COOKIE_VM_INGRESS_TABLE, instructions);
1409         return serviceInfo;
1410     }
1411
1412     static BoundServices getBoundServicesForTunnelInterface(String vpnName, String interfaceName) {
1413         int instructionKey = 0;
1414         List<Instruction> instructions = new ArrayList<>();
1415         instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(
1416                 NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, ++instructionKey));
1417         BoundServices serviceInfo = InterfaceUtils.getBoundServices(String.format("%s.%s.%s", "vpn",
1418                 vpnName, interfaceName),
1419                 ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
1420                         NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE), VpnConstants.DEFAULT_FLOW_PRIORITY,
1421                 NwConstants.COOKIE_VM_INGRESS_TABLE, instructions);
1422         return serviceInfo;
1423     }
1424
1425     void unbindService(final String vpnInterfaceName, boolean isInterfaceStateDown) {
1426         if (!isInterfaceStateDown) {
1427             jobCoordinator.enqueueJob(vpnInterfaceName,
1428                 () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
1429                         Datastore.CONFIGURATION, tx ->
1430                         tx.delete(InterfaceUtils.buildServiceId(vpnInterfaceName,
1431                                         ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
1432                                                 NwConstants.L3VPN_SERVICE_INDEX))))),
1433                 SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
1434         }
1435     }
1436
1437     static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId) {
1438         return new FlowEntityBuilder().setDpnId(dpnId).setTableId(tableId).setFlowId(flowId).build();
1439     }
1440
1441     static VrfEntryBase.EncapType getEncapType(boolean isVxLan) {
1442         return isVxLan ? VrfEntryBase.EncapType.Vxlan : VrfEntryBase.EncapType.Mplsgre;
1443     }
1444
1445     org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets
1446         getExternalSubnet(Uuid subnetId) {
1447         InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
1448             .Subnets> subnetsIdentifier = InstanceIdentifier.builder(ExternalSubnets.class)
1449                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
1450                         .Subnets.class, new SubnetsKey(subnetId)).build();
1451         Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets>
1452             optionalSubnets = read(LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
1453         return optionalSubnets.isPresent() ? optionalSubnets.get() : null;
1454     }
1455
1456     Uuid getSubnetFromExternalRouterByIp(Uuid routerId, String ip) {
1457         Routers externalRouter = getExternalRouter(routerId.getValue());
1458         if (externalRouter != null && externalRouter.getExternalIps() != null) {
1459             for (ExternalIps externalIp : externalRouter.getExternalIps()) {
1460                 if (externalIp.getIpAddress().equals(ip)) {
1461                     return externalIp.getSubnetId();
1462                 }
1463             }
1464         }
1465         return null;
1466     }
1467
1468     static boolean isExternalSubnetVpn(String vpnName, String subnetId) {
1469         return vpnName.equals(subnetId);
1470     }
1471
1472     static Boolean getIsExternal(Network network) {
1473         return network.augmentation(NetworkL3Extension.class) != null
1474                 && network.augmentation(NetworkL3Extension.class).isExternal();
1475     }
1476
1477     @SuppressWarnings("checkstyle:linelength")
1478     Network getNeutronNetwork(Uuid networkId) {
1479         Network network = null;
1480         LOG.debug("getNeutronNetwork for {}", networkId.getValue());
1481         InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class).child(
1482                 org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks.class).child(
1483                 Network.class, new NetworkKey(networkId));
1484         Optional<Network> net = read(LogicalDatastoreType.CONFIGURATION, inst);
1485         if (net.isPresent()) {
1486             network = net.get();
1487         }
1488         return network;
1489     }
1490
1491     public static boolean isEligibleForBgp(String rd, String vpnName, BigInteger dpnId, String networkName) {
1492         if (rd != null) {
1493             if (vpnName != null && rd.equals(vpnName)) {
1494                 return false;
1495             }
1496             if (dpnId != null && rd.equals(dpnId.toString())) {
1497                 return false;
1498             }
1499             if (networkName != null && rd.equals(networkName)) {
1500                 return false;
1501             }
1502             return true;
1503         }
1504         return false;
1505     }
1506
1507     static String getFibFlowRef(BigInteger dpnId, short tableId, String vpnName, int priority) {
1508         return VpnConstants.FLOWID_PREFIX + dpnId + NwConstants.FLOWID_SEPARATOR + tableId
1509                 + NwConstants.FLOWID_SEPARATOR + vpnName + NwConstants.FLOWID_SEPARATOR + priority;
1510     }
1511
1512     void removeExternalTunnelDemuxFlows(String vpnName) {
1513         LOG.info("Removing external tunnel flows for vpn {}", vpnName);
1514         for (BigInteger dpnId: NWUtil.getOperativeDPNs(dataBroker)) {
1515             LOG.debug("Removing external tunnel flows for vpn {} from dpn {}", vpnName, dpnId);
1516             String flowRef = getFibFlowRef(dpnId, NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
1517                     vpnName, VpnConstants.DEFAULT_FLOW_PRIORITY);
1518             FlowEntity flowEntity = VpnUtil.buildFlowEntity(dpnId,
1519                     NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE, flowRef);
1520             mdsalManager.removeFlow(flowEntity);
1521         }
1522     }
1523
1524     public boolean isVpnPendingDelete(String rd) {
1525         VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
1526         boolean isVpnPendingDelete = false;
1527         if (vpnInstanceOpData == null
1528                 || vpnInstanceOpData.getVpnState() == VpnInstanceOpDataEntry.VpnState.PendingDelete) {
1529             isVpnPendingDelete = true;
1530         }
1531         return isVpnPendingDelete;
1532     }
1533
1534     public List<VpnInstanceOpDataEntry> getVpnsImportingMyRoute(final String vpnName) {
1535         List<VpnInstanceOpDataEntry> vpnsToImportRoute = new ArrayList<>();
1536         final String vpnRd = getVpnRd(vpnName);
1537         if (vpnRd == null) {
1538             LOG.error("getVpnsImportingMyRoute: vpn {} not present in config DS.", vpnName);
1539             return vpnsToImportRoute;
1540         }
1541         final VpnInstanceOpDataEntry vpnInstanceOpDataEntry = getVpnInstanceOpData(vpnRd);
1542         if (vpnInstanceOpDataEntry == null) {
1543             LOG.error("getVpnsImportingMyRoute: Could not retrieve vpn instance op data for {}"
1544                     + " to check for vpns importing the routes", vpnName);
1545             return vpnsToImportRoute;
1546         }
1547         Predicate<VpnInstanceOpDataEntry> excludeVpn = input -> {
1548             if (input.getVpnInstanceName() == null) {
1549                 LOG.error("getVpnsImportingMyRoute.excludeVpn: Received vpn instance with rd {} without a name.",
1550                         input.getVrfId());
1551                 return false;
1552             }
1553             return !input.getVpnInstanceName().equals(vpnName);
1554         };
1555         Predicate<VpnInstanceOpDataEntry> matchRTs = input -> {
1556             Iterable<String> commonRTs =
1557                 intersection(getRts(vpnInstanceOpDataEntry, VpnTarget.VrfRTType.ExportExtcommunity),
1558                     getRts(input, VpnTarget.VrfRTType.ImportExtcommunity));
1559             return Iterators.size(commonRTs.iterator()) > 0;
1560         };
1561         vpnsToImportRoute = getAllVpnInstanceOpData().stream().filter(excludeVpn).filter(matchRTs)
1562                 .collect(Collectors.toList());
1563         return vpnsToImportRoute;
1564     }
1565
1566     static List<String> getRts(VpnInstanceOpDataEntry vpnInstance, VpnTarget.VrfRTType rtType) {
1567         String name = vpnInstance.getVpnInstanceName();
1568         List<String> rts = new ArrayList<>();
1569         VpnTargets targets = vpnInstance.getVpnTargets();
1570         if (targets == null) {
1571             LOG.info("getRts: vpn targets not available for {}", name);
1572             return rts;
1573         }
1574         List<VpnTarget> vpnTargets = targets.getVpnTarget();
1575         if (vpnTargets == null) {
1576             LOG.info("getRts: vpnTarget values not available for {}", name);
1577             return rts;
1578         }
1579         for (VpnTarget target : vpnTargets) {
1580             //TODO: Check for RT type is Both
1581             if (target.getVrfRTType().equals(rtType) || target.getVrfRTType().equals(VpnTarget.VrfRTType.Both)) {
1582                 String rtValue = target.getVrfRTValue();
1583                 rts.add(rtValue);
1584             }
1585         }
1586         return rts;
1587     }
1588
1589     static <T> Iterable<T> intersection(final Collection<T> collection1, final Collection<T> collection2) {
1590         Set<T> intersection = new HashSet<>(collection1);
1591         intersection.retainAll(collection2);
1592         return intersection;
1593     }
1594
1595     /** Get Subnetmap from its Uuid.
1596      * @param subnetUuid the subnet's Uuid
1597      * @return the Subnetmap of Uuid or null if it is not found
1598      */
1599     Subnetmap getSubnetmapFromItsUuid(Uuid subnetUuid) {
1600         Subnetmap sn = null;
1601         InstanceIdentifier<Subnetmap> id = buildSubnetmapIdentifier(subnetUuid);
1602         Optional<Subnetmap> optionalSn = read(LogicalDatastoreType.CONFIGURATION, id);
1603         if (optionalSn.isPresent()) {
1604             sn = optionalSn.get();
1605         }
1606         return sn;
1607     }
1608
1609     boolean isAdjacencyEligibleToVpnInternet(Adjacency adjacency) {
1610         // returns true if BGPVPN Internet and adjacency is IPv6, false otherwise
1611         boolean adjacencyEligible = true;
1612         if (adjacency.getAdjacencyType() == AdjacencyType.ExtraRoute) {
1613             if (FibHelper.isIpv6Prefix(adjacency.getIpAddress())) {
1614                 return adjacencyEligible;
1615             }
1616             return false;
1617         } else if (adjacency.getSubnetId() == null) {
1618             return adjacencyEligible;
1619         }
1620         Subnetmap sn = getSubnetmapFromItsUuid(adjacency.getSubnetId());
1621         if (sn != null && sn.getInternetVpnId() != null) {
1622             adjacencyEligible = false;
1623         }
1624         return adjacencyEligible;
1625     }
1626
1627     boolean isAdjacencyEligibleToVpn(Adjacency adjacency, String vpnName) {
1628         // returns true if BGPVPN Internet and adjacency is IPv6, false otherwise
1629         boolean adjacencyEligible = true;
1630         // if BGPVPN internet, return false if subnetmap has not internetVpnId() filled in
1631         if (isBgpVpnInternet(vpnName)) {
1632             return isAdjacencyEligibleToVpnInternet(adjacency);
1633         }
1634         return adjacencyEligible;
1635     }
1636
1637     String getInternetVpnFromVpnInstanceList(List<VpnInstanceNames> vpnInstanceList) {
1638         for (VpnInstanceNames vpnInstance : vpnInstanceList) {
1639             String vpnName = vpnInstance.getVpnName();
1640             if (isBgpVpnInternet(vpnName)) {
1641                 return vpnName;
1642             }
1643         }
1644         return null;
1645     }
1646
1647     /** Get boolean true if vpn is bgpvpn internet, false otherwise.
1648      * @param vpnName name of the input VPN
1649      * @return true or false
1650      */
1651     boolean isBgpVpnInternet(String vpnName) {
1652         String primaryRd = getVpnRd(vpnName);
1653         if (primaryRd == null) {
1654             LOG.error("isBgpVpnInternet VPN {}."
1655                       + "Primary RD not found", vpnName);
1656             return false;
1657         }
1658         InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier.builder(VpnInstanceOpData.class)
1659               .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(primaryRd)).build();
1660
1661         Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional = read(LogicalDatastoreType.OPERATIONAL, id);
1662         if (!vpnInstanceOpDataEntryOptional.isPresent()) {
1663             LOG.error("isBgpVpnInternet VPN {}."
1664                      + "VpnInstanceOpDataEntry not found", vpnName);
1665             return false;
1666         }
1667         LOG.debug("isBgpVpnInternet VPN {}."
1668              + "Successfully VpnInstanceOpDataEntry.getBgpvpnType {}",
1669              vpnName, vpnInstanceOpDataEntryOptional.get().getBgpvpnType());
1670         if (vpnInstanceOpDataEntryOptional.get().getBgpvpnType() == VpnInstanceOpDataEntry
1671                .BgpvpnType.BGPVPNInternet) {
1672             return true;
1673         }
1674         return false;
1675     }
1676
1677     /**Get IpVersionChoice from String IP like x.x.x.x or an representation IPv6.
1678      * @param ipAddress String of an representation IP address V4 or V6
1679      * @return the IpVersionChoice of the version or IpVersionChoice.UNDEFINED otherwise
1680      */
1681     public static IpVersionChoice getIpVersionFromString(String ipAddress) {
1682         IpVersionChoice ipchoice = IpVersionChoice.UNDEFINED;
1683         int indexIpAddress = ipAddress.indexOf('/');
1684         if (indexIpAddress >= 0) {
1685             ipAddress = ipAddress.substring(0, indexIpAddress);
1686         }
1687         try {
1688             InetAddress address = InetAddress.getByName(ipAddress);
1689             if (address instanceof Inet4Address) {
1690                 return IpVersionChoice.IPV4;
1691             } else if (address instanceof Inet6Address) {
1692                 return IpVersionChoice.IPV6;
1693             }
1694         } catch (UnknownHostException | SecurityException e) {
1695             ipchoice = IpVersionChoice.UNDEFINED;
1696         }
1697         return ipchoice;
1698     }
1699
1700     ListenableFuture<Void> unsetScheduledToRemoveForVpnInterface(String interfaceName) {
1701         VpnInterfaceBuilder builder = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(interfaceName))
1702                 .setScheduledForRemove(false);
1703         return txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL, tx -> tx.merge(
1704                 VpnUtil.getVpnInterfaceIdentifier(interfaceName), builder.build(),
1705                 WriteTransaction.CREATE_MISSING_PARENTS));
1706     }
1707
1708     /**
1709      * Adds router port for all elan network of type VLAN which is a part of vpnName in the DPN with dpnId.
1710      * This will create the vlan footprint in the DPN's which are member of the VPN.
1711      *
1712      * @param vpnName the vpnName
1713      * @param dpnId  the DPN id
1714      */
1715     void addRouterPortToElanForVlanInDpn(String vpnName, BigInteger dpnId) {
1716         Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
1717         for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
1718             addRouterPortToElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(), dpnId);
1719         }
1720     }
1721
1722     /**
1723      * Removes router port for all elan network of type VLAN which is a part of vpnName in the DPN with dpnId.
1724      * This will remove the  vlan footprint in all the DPN's which are member of the VPN.
1725      *
1726      * @param vpnName the vpn name
1727      * @param dpnId  the DPN id
1728      */
1729     void removeRouterPortFromElanForVlanInDpn(String vpnName, BigInteger dpnId) {
1730         Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
1731         for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
1732             removeRouterPortFromElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(),
1733                     vpnName, dpnId);
1734         }
1735     }
1736
1737     /**
1738      * Adds router port for all elan network of type VLAN which is a part of vpnName in all the DPN which has a port
1739      * This will create the vlan footprint in all the DPN's which are member of the VPN.
1740      *
1741      * @param vpnName the vpn name
1742      */
1743     void addRouterPortToElanDpnListForVlaninAllDpn(String vpnName) {
1744         Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
1745         Set<BigInteger> dpnList = getDpnInElan(elanInstanceRouterPortMap);
1746         for (BigInteger dpnId : dpnList) {
1747             for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
1748                 addRouterPortToElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(), dpnId);
1749             }
1750         }
1751     }
1752
1753     /**Removes router port for all elan network of type VLAN which is a part of vpnName in all the DPN which has a port
1754      * This will remove the vlan footprint in all the DPN's which are member of the VPN.
1755      *
1756      * @param routerInterfacePortId this will add the current subnet router port id to the map for removal
1757      * @param elanInstanceName the current elanstance being removed this will be added to map for removal
1758      * @param vpnName the vpn name
1759      */
1760     void removeRouterPortFromElanDpnListForVlanInAllDpn(String elanInstanceName,
1761             String routerInterfacePortId, String vpnName) {
1762         Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
1763         elanInstanceRouterPortMap.put(elanInstanceName, routerInterfacePortId);
1764         Set<BigInteger> dpnList = getDpnInElan(elanInstanceRouterPortMap);
1765         for (BigInteger dpnId : dpnList) {
1766             for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
1767                 removeRouterPortFromElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(),
1768                         vpnName, dpnId);
1769             }
1770         }
1771
1772     }
1773
1774     Set<BigInteger> getDpnInElan(Map<String,String> elanInstanceRouterPortMap) {
1775         Set<BigInteger> dpnIdSet = new HashSet<>();
1776         for (String elanInstanceName : elanInstanceRouterPortMap.keySet()) {
1777             InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationalDataPath(
1778                     elanInstanceName);
1779             Optional<ElanDpnInterfacesList> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL,
1780                     elanDpnInterfaceId);
1781             if (dpnInElanInterfaces.isPresent()) {
1782                 List<DpnInterfaces> dpnInterfaces = dpnInElanInterfaces.get().getDpnInterfaces();
1783                 for (DpnInterfaces dpnInterface : dpnInterfaces) {
1784                     dpnIdSet.add(dpnInterface.getDpId());
1785                 }
1786             }
1787         }
1788         return dpnIdSet;
1789     }
1790
1791     void addRouterPortToElanDpn(String elanInstanceName, String routerInterfacePortId, BigInteger dpnId) {
1792         InstanceIdentifier<DpnInterfaces> elanDpnInterfaceId = getElanDpnInterfaceOperationalDataPath(
1793                 elanInstanceName,dpnId);
1794         synchronized (elanInstanceName.intern()) {
1795             Optional<DpnInterfaces> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
1796             List<String> elanInterfaceList;
1797             DpnInterfaces dpnInterface;
1798             if (!dpnInElanInterfaces.isPresent()) {
1799                 elanInterfaceList = new ArrayList<>();
1800             } else {
1801                 dpnInterface = dpnInElanInterfaces.get();
1802                 elanInterfaceList = dpnInterface.getInterfaces();
1803             }
1804             if (!elanInterfaceList.contains(routerInterfacePortId)) {
1805                 elanInterfaceList.add(routerInterfacePortId);
1806                 dpnInterface = new DpnInterfacesBuilder().setDpId(dpnId).setInterfaces(elanInterfaceList)
1807                         .withKey(new DpnInterfacesKey(dpnId)).build();
1808                 syncWrite(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId, dpnInterface);
1809             }
1810         }
1811
1812     }
1813
1814     void removeRouterPortFromElanDpn(String elanInstanceName, String routerInterfacePortId,
1815             String vpnName, BigInteger dpnId) {
1816         InstanceIdentifier<DpnInterfaces> elanDpnInterfaceId = getElanDpnInterfaceOperationalDataPath(
1817                 elanInstanceName,dpnId);
1818         synchronized (elanInstanceName.intern()) {
1819             Optional<DpnInterfaces> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
1820             List<String> elanInterfaceList;
1821             DpnInterfaces dpnInterface;
1822             if (!dpnInElanInterfaces.isPresent()) {
1823                 LOG.info("No interface in any dpn for {}", vpnName);
1824                 return;
1825             } else {
1826                 dpnInterface = dpnInElanInterfaces.get();
1827                 elanInterfaceList = dpnInterface.getInterfaces();
1828             }
1829             if (!elanInterfaceList.contains(routerInterfacePortId)) {
1830                 LOG.info("Router port not present in DPN {} for VPN {}", dpnId, vpnName);
1831                 return;
1832             }
1833             elanInterfaceList.remove(routerInterfacePortId);
1834             dpnInterface = new DpnInterfacesBuilder().setDpId(dpnId).setInterfaces(elanInterfaceList)
1835                     .withKey(new DpnInterfacesKey(dpnId)).build();
1836             syncWrite(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId, dpnInterface);
1837         }
1838
1839     }
1840
1841     ElanInterface getElanInterfaceByElanInterfaceName(String elanInterfaceName) {
1842         InstanceIdentifier<ElanInterface> elanInterfaceId = getElanInterfaceConfigurationDataPathId(elanInterfaceName);
1843         return read(LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orNull();
1844     }
1845
1846     static InstanceIdentifier<ElanInterface> getElanInterfaceConfigurationDataPathId(String interfaceName) {
1847         return InstanceIdentifier.builder(ElanInterfaces.class)
1848                 .child(ElanInterface.class, new ElanInterfaceKey(interfaceName)).build();
1849     }
1850
1851     DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, BigInteger dpId) {
1852         InstanceIdentifier<DpnInterfaces> elanDpnInterfacesId = getElanDpnInterfaceOperationalDataPath(elanInstanceName,
1853                 dpId);
1854         return read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orNull();
1855     }
1856
1857     String getExternalElanInterface(String elanInstanceName, BigInteger dpnId) {
1858         DpnInterfaces dpnInterfaces = getElanInterfaceInfoByElanDpn(elanInstanceName, dpnId);
1859         if (dpnInterfaces == null || dpnInterfaces.getInterfaces() == null) {
1860             LOG.info("Elan {} does not have interfaces in DPN {}", elanInstanceName, dpnId);
1861             return null;
1862         }
1863
1864         for (String dpnInterface : dpnInterfaces.getInterfaces()) {
1865             if (interfaceManager.isExternalInterface(dpnInterface)) {
1866                 return dpnInterface;
1867             }
1868         }
1869         return null;
1870     }
1871
1872     static boolean isVlan(ElanInstance elanInstance) {
1873         return elanInstance != null && elanInstance.getSegmentType() != null
1874                 && elanInstance.getSegmentType().isAssignableFrom(SegmentTypeVlan.class)
1875                 && elanInstance.getSegmentationId() != null && elanInstance.getSegmentationId() != 0;
1876     }
1877
1878     boolean isVlan(String interfaceName) {
1879         ElanInterface elanInterface = getElanInterfaceByElanInterfaceName(interfaceName);
1880         if (elanInterface == null) {
1881             return false;
1882         }
1883         ElanInstance  elanInstance = getElanInstanceByName(elanInterface.getElanInstanceName());
1884         return isVlan(elanInstance);
1885     }
1886
1887     ElanInstance getElanInstanceByName(String elanInstanceName) {
1888         InstanceIdentifier<ElanInstance> elanIdentifierId =
1889                 ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName);
1890         return read(LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
1891     }
1892
1893     String getVpnNameFromElanIntanceName(String elanInstanceName) {
1894         Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
1895         if (subnetMapsData.isPresent()) {
1896             List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
1897             if (subnetMapList != null && !subnetMapList.isEmpty()) {
1898                 for (Subnetmap subnet : subnetMapList) {
1899                     if (subnet.getNetworkId().getValue().equals(elanInstanceName)) {
1900                         if (subnet.getVpnId() != null) {
1901                             return subnet.getVpnId().getValue();
1902                         }
1903                     }
1904                 }
1905             }
1906         }
1907         return null;
1908     }
1909
1910     Map<String, String> getElanInstanceRouterPortMap(String vpnName) {
1911         Map<String, String> elanInstanceRouterPortMap = new HashMap<>();
1912         Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
1913         if (subnetMapsData.isPresent()) {
1914             List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
1915             if (subnetMapList != null && !subnetMapList.isEmpty()) {
1916                 for (Subnetmap subnet : subnetMapList) {
1917                     if (subnet.getVpnId() != null && subnet.getVpnId().getValue().equals(vpnName)
1918                             && subnet.getNetworkType().equals(NetworkType.VLAN)) {
1919                         if (subnet.getRouterInterfacePortId() == null || subnet.getNetworkId() == null) {
1920                             LOG.warn("The RouterInterfacePortId or NetworkId is null");
1921                             continue;
1922                         }
1923                         String routerInterfacePortUuid = subnet.getRouterInterfacePortId().getValue();
1924                         if (routerInterfacePortUuid != null && !routerInterfacePortUuid.isEmpty()) {
1925                             elanInstanceRouterPortMap.put(subnet.getNetworkId().getValue(),routerInterfacePortUuid);
1926                         }
1927                     }
1928                 }
1929             }
1930         }
1931         return elanInstanceRouterPortMap;
1932     }
1933
1934     String getRouterPordIdFromElanInstance(String elanInstanceName) {
1935         Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
1936         if (subnetMapsData.isPresent()) {
1937             List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
1938             if (subnetMapList != null && !subnetMapList.isEmpty()) {
1939                 for (Subnetmap subnet : subnetMapList) {
1940                     if (subnet.getNetworkId().getValue().equals(elanInstanceName)) {
1941                         if (subnet.getRouterInterfacePortId() != null) {
1942                             return subnet.getRouterInterfacePortId().getValue();
1943                         }
1944                     }
1945                 }
1946             }
1947         }
1948         return null;
1949     }
1950
1951     boolean shouldPopulateFibForVlan(String vpnName, String elanInstanceName, BigInteger dpnId) {
1952         Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
1953         boolean shouldPopulateFibForVlan = false;
1954         if (!elanInstanceRouterPortMap.isEmpty()) {
1955             shouldPopulateFibForVlan = true;
1956         }
1957         for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap
1958                 .entrySet()) {
1959             String currentElanInstance = elanInstanceRouterEntry.getKey();
1960             if (elanInstanceName != null && elanInstanceName.equals(currentElanInstance)) {
1961                 continue;
1962             }
1963             String externalinterface = getExternalElanInterface(currentElanInstance ,dpnId);
1964             if (externalinterface == null) {
1965                 shouldPopulateFibForVlan = false;
1966                 break;
1967             }
1968         }
1969         return shouldPopulateFibForVlan;
1970     }
1971
1972     public static InstanceIdentifier<DpnInterfaces> getElanDpnInterfaceOperationalDataPath(String elanInstanceName,
1973             BigInteger dpId) {
1974         return InstanceIdentifier.builder(ElanDpnInterfaces.class)
1975                 .child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName))
1976                 .child(DpnInterfaces.class, new DpnInterfacesKey(dpId)).build();
1977     }
1978
1979     public static InstanceIdentifier<ElanDpnInterfacesList> getElanDpnOperationalDataPath(String elanInstanceName) {
1980         return InstanceIdentifier.builder(ElanDpnInterfaces.class)
1981                 .child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName))
1982                 .build();
1983     }
1984
1985     public static boolean isMatchedPrefixToInterface(Prefixes prefix, VpnInterfaceOpDataEntry vpnInterface) {
1986         if (prefix != null && vpnInterface != null) {
1987             if (prefix.getDpnId() != null && vpnInterface.getDpnId() != null) {
1988                 if (prefix.getVpnInterfaceName() != null && vpnInterface.getName() != null) {
1989                     return prefix.getDpnId().equals(vpnInterface.getDpnId())
1990                             && prefix.getVpnInterfaceName().equalsIgnoreCase(vpnInterface.getName());
1991                 }
1992             }
1993         }
1994         return false;
1995     }
1996
1997     void removePrefixToInterfaceAdj(Adjacency adj, long vpnId, VpnInterfaceOpDataEntry vpnInterfaceOpDataEntry,
1998                                     WriteTransaction writeOperTxn) {
1999         if (writeOperTxn == null) {
2000             ListenableFutures.addErrorLogging(
2001                     txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
2002                         removePrefixToInterfaceAdj(adj, vpnId, vpnInterfaceOpDataEntry, tx)), LOG,
2003                     "Error removing prefix");
2004             return;
2005         }
2006
2007         Optional<Prefixes> prefix = read(LogicalDatastoreType.OPERATIONAL,
2008                 VpnUtil.getPrefixToInterfaceIdentifier(vpnId, VpnUtil.getIpPrefix(adj.getIpAddress())));
2009         List<Prefixes> prefixToInterface = new ArrayList<>();
2010         List<Prefixes> prefixToInterfaceLocal = new ArrayList<>();
2011         if (prefix.isPresent()) {
2012             prefixToInterfaceLocal.add(prefix.get());
2013         }
2014         if (prefixToInterfaceLocal.isEmpty()) {
2015             for (String nh : adj.getNextHopIpList()) {
2016                 prefix = read(LogicalDatastoreType.OPERATIONAL, VpnUtil.getPrefixToInterfaceIdentifier(vpnId,
2017                                 VpnUtil.getIpPrefix(nh)));
2018                 if (prefix.isPresent()) {
2019                     prefixToInterfaceLocal.add(prefix.get());
2020                 }
2021             }
2022         }
2023         if (!prefixToInterfaceLocal.isEmpty()) {
2024             prefixToInterface.addAll(prefixToInterfaceLocal);
2025         }
2026         for (Prefixes pref : prefixToInterface) {
2027             if (VpnUtil.isMatchedPrefixToInterface(pref, vpnInterfaceOpDataEntry)) {
2028                 writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL,
2029                         VpnUtil.getPrefixToInterfaceIdentifier(vpnId, pref.getIpAddress()));
2030             }
2031         }
2032     }
2033
2034     public static void sendNeighborSolicationToOfGroup(Ipv6NdUtilService ipv6NdUtilService, Ipv6Address srcIpv6Address,
2035             MacAddress srcMac, Ipv6Address dstIpv6Address, Long ofGroupId, BigInteger dpId) {
2036         SendNeighborSolicitationToOfGroupInput input = new SendNeighborSolicitationToOfGroupInputBuilder()
2037                 .setSourceIpv6(srcIpv6Address).setSourceLlAddress(srcMac).setTargetIpAddress(dstIpv6Address)
2038                 .setOfGroupId(ofGroupId).setDpId(dpId).build();
2039         try {
2040             Future<RpcResult<SendNeighborSolicitationToOfGroupOutput>> result = ipv6NdUtilService
2041                     .sendNeighborSolicitationToOfGroup(input);
2042             RpcResult<SendNeighborSolicitationToOfGroupOutput> rpcResult = result.get();
2043             if (!rpcResult.isSuccessful()) {
2044                 LOG.error("sendNeighborSolicitationToOfGroup: RPC Call failed for input={} and Errors={}", input,
2045                         rpcResult.getErrors());
2046             }
2047         } catch (InterruptedException | ExecutionException e) {
2048             LOG.error("Failed to send NS packet to ELAN group, input={}", input, e);
2049         }
2050     }
2051
2052     Set<org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets.VpnTarget>
2053         getRtListForVpn(String vpnName) {
2054         Set<org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets
2055                 .VpnTarget> rtList = new HashSet<>();
2056         InstanceIdentifier<VpnInstance> vpnInstanceId = InstanceIdentifier.builder(VpnInstances.class)
2057                 .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
2058         Optional<VpnInstance> vpnInstanceOptional = read(LogicalDatastoreType.CONFIGURATION, vpnInstanceId);
2059         if (vpnInstanceOptional.isPresent()) {
2060             org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.VpnTargets
2061                     vpnTargets = vpnInstanceOptional.get().getIpv4Family().getVpnTargets();
2062             if (vpnTargets != null && vpnTargets.getVpnTarget() != null) {
2063                 rtList.addAll(vpnTargets.getVpnTarget());
2064             }
2065         }
2066         else {
2067             LOG.error("getRtListForVpn: Vpn Instance {} not present in config DS", vpnName);
2068         }
2069         return rtList;
2070     }
2071
2072     static InstanceIdentifier<AssociatedVpn> getAssociatedSubnetAndVpnIdentifier(String rt, RouteTarget.RtType rtType,
2073                                                                                  String cidr, String vpnName) {
2074         return InstanceIdentifier.builder(SubnetsAssociatedToRouteTargets.class).child(RouteTarget.class,
2075                 new RouteTargetKey(rt, rtType)).child(AssociatedSubnet.class, new AssociatedSubnetKey(cidr))
2076                 .child(AssociatedVpn.class, new AssociatedVpnKey(vpnName)).build();
2077     }
2078
2079     static InstanceIdentifier<AssociatedSubnet> getAssociatedSubnetIdentifier(String rt, RouteTarget.RtType rtType,
2080                                                                        String cidr) {
2081         return InstanceIdentifier.builder(SubnetsAssociatedToRouteTargets.class).child(RouteTarget.class,
2082                 new RouteTargetKey(rt, rtType)).child(AssociatedSubnet.class, new AssociatedSubnetKey(cidr)).build();
2083     }
2084
2085     static AssociatedVpn buildAssociatedSubnetAndVpn(String vpnName) {
2086         return new AssociatedVpnBuilder().setName(vpnName).build();
2087     }
2088
2089     static InstanceIdentifier<RouteTarget> getRouteTargetsIdentifier(String rt, RouteTarget.RtType rtType) {
2090         return InstanceIdentifier.builder(SubnetsAssociatedToRouteTargets.class)
2091                 .child(RouteTarget.class, new RouteTargetKey(rt, rtType)).build();
2092     }
2093
2094     Set<RouteTarget> getRouteTargetSet(Set<org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815
2095             .vpn.af.config.vpntargets.VpnTarget> vpnTargets) {
2096         Set<RouteTarget> routeTargetSet = new HashSet<>();
2097         for (org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.af.config.vpntargets
2098                 .VpnTarget rt : vpnTargets) {
2099             String rtValue = rt.getVrfRTValue();
2100             switch (rt.getVrfRTType()) {
2101                 case ImportExtcommunity: {
2102                     Optional<RouteTarget> exportRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
2103                             getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.ERT));
2104                     if (exportRouteTargetOptional.isPresent()) {
2105                         routeTargetSet.add(exportRouteTargetOptional.get());
2106                     }
2107                     break;
2108                 }
2109                 case ExportExtcommunity: {
2110                     Optional<RouteTarget> importRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
2111                             getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.IRT));
2112                     if (importRouteTargetOptional.isPresent()) {
2113                         routeTargetSet.add(importRouteTargetOptional.get());
2114                     }
2115                     break;
2116                 }
2117                 case Both: {
2118                     Optional<RouteTarget> exportRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
2119                             getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.ERT));
2120                     if (exportRouteTargetOptional.isPresent()) {
2121                         routeTargetSet.add(exportRouteTargetOptional.get());
2122                     }
2123                     Optional<RouteTarget> importRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
2124                             getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.IRT));
2125                     if (importRouteTargetOptional.isPresent()) {
2126                         routeTargetSet.add(importRouteTargetOptional.get());
2127                     }
2128                     break;
2129                 }
2130                 default:
2131                     LOG.error("getRouteTargetSet: Invalid rt-type {}", rt.getVrfRTType());
2132             }
2133         }
2134         return routeTargetSet;
2135     }
2136
2137     /*
2138     TODO: (vivek/kiran): Subnet overlap in a VPN detection logic should use subnet allocation pools if available
2139            rather than only CIDR.
2140            Also the Subnet overlap in a VPN detection logic to be addressed for router-based-l3vpns.
2141     */
2142     static boolean areSubnetsOverlapping(String cidr1, String cidr2) {
2143         String[] ipaddressValues1 = cidr1.split("/");
2144         int address1 = InetAddresses.coerceToInteger(InetAddresses.forString(ipaddressValues1[0]));
2145         int cidrPart1 = Integer.parseInt(ipaddressValues1[1]);
2146         String[] ipaddressValues2 = cidr2.split("/");
2147         int address2 = InetAddresses.coerceToInteger(InetAddresses.forString(ipaddressValues2[0]));
2148         int cidrPart2 = Integer.parseInt(ipaddressValues2[1]);
2149         int comparedValue = 0;
2150         int netmask = 0;
2151         if (cidrPart1 <= cidrPart2) {
2152             for (int j = 0; j < cidrPart1; ++j) {
2153                 netmask |= (1 << 31 - j);
2154             }
2155             int prefix = address2 & netmask;
2156             comparedValue = address1 ^ prefix;
2157         } else {
2158             for (int j = 0; j < cidrPart2; ++j) {
2159                 netmask |= (1 << 31 - j);
2160             }
2161             int prefix = address1 & netmask;
2162             comparedValue = address2 ^ prefix;
2163         }
2164         if (comparedValue == 0) {
2165             return  true;
2166         } else {
2167             return false;
2168         }
2169     }
2170 }