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