package org.opendaylight.netvirt.vpnmanager;
+import static java.util.Collections.emptyList;
+import static org.opendaylight.genius.infra.Datastore.OPERATIONAL;
+
import com.google.common.base.Optional;
import com.google.common.collect.Iterators;
+import com.google.common.net.InetAddresses;
import com.google.common.util.concurrent.FutureCallback;
-import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
import java.math.BigInteger;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
+import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
+import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Predicate;
import java.util.stream.Collectors;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
+import javax.inject.Singleton;
+import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.jdt.annotation.Nullable;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.infra.Datastore;
+import org.opendaylight.genius.infra.Datastore.Configuration;
+import org.opendaylight.genius.infra.Datastore.Operational;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
+import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.genius.infra.TypedReadTransaction;
+import org.opendaylight.genius.infra.TypedReadWriteTransaction;
+import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
import org.opendaylight.genius.mdsalutil.FlowEntity;
import org.opendaylight.genius.mdsalutil.FlowEntityBuilder;
import org.opendaylight.genius.mdsalutil.instructions.InstructionWriteMetadata;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchEthernetDestination;
+import org.opendaylight.genius.mdsalutil.matches.MatchEthernetType;
import org.opendaylight.genius.mdsalutil.matches.MatchMetadata;
+import org.opendaylight.genius.utils.JvmGlobalLocks;
import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.genius.utils.SystemPropertyReader;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
import org.opendaylight.netvirt.bgpmanager.api.IBgpManager;
import org.opendaylight.netvirt.elanmanager.api.ElanHelper;
-import org.opendaylight.netvirt.fibmanager.api.FibHelper;
+import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.neutronvpn.api.enums.IpVersionChoice;
import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
import org.opendaylight.netvirt.vpnmanager.api.InterfaceUtils;
import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnAfConfig;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInstances;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.VpnInterfaces;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstance;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.instances.VpnInstanceKey;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterface;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.VpnInterfaceKey;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNames;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNames.AssociatedSubnetType;
-import org.opendaylight.yang.gen.v1.urn.huawei.params.xml.ns.yang.l3vpn.rev140815.vpn.interfaces.vpn._interface.VpnInstanceNamesBuilder;
+import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdPools;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPool;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.id.pools.IdPoolKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406.IfIndexesInterfaceMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.meta.rev160406._if.indexes._interface.map.IfIndexInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetInterfaceFromIfIndexOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.service.bindings.services.info.BoundServices;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.Ipv6NdUtilService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.SendNeighborSolicitationToOfGroupInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.SendNeighborSolicitationToOfGroupInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.ipv6.nd.util.rev170210.SendNeighborSolicitationToOfGroupOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.LockManagerService;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TimeUnits;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.TryLockOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.lockmanager.rev160413.UnlockOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanDpnInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.elan.rev150602.ElanTagNameMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.L3nexthop;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthops;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3nexthop.rev150409.l3nexthop.VpnNexthopsKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.Adjacencies;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOp;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.AdjacenciesOpBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventAction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.LearntVpnVipToPortEventData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.PrefixToInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.RouterInterfaces;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetOpData;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.SubnetsAssociatedToRouteTargets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnIdToVpnInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceOpData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInstanceToVpnId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnInterfaceOpData;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.VpnToExtraroutes;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.Adjacency.AdjacencyType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.adjacency.list.AdjacencyKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPort;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.data.LearntVpnVipToPortKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.event.data.LearntVpnVipToPortEvent;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.event.data.LearntVpnVipToPortEventBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.learnt.vpn.vip.to.port.event.data.LearntVpnVipToPortEventKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIds;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.VpnIdsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.PrefixesKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.router.interfaces.RouterInterfaceKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnet.op.data.SubnetOpDataEntryKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.RouteTarget;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.RouteTargetKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.AssociatedSubnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.AssociatedSubnetKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.associated.subnet.AssociatedVpn;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.associated.subnet.AssociatedVpnBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.subnets.associated.to.route.targets.route.target.associated.subnet.AssociatedVpnKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn._interface.op.data.VpnInterfaceOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.VpnInstanceOpDataEntryKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnTargets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.vpntargets.VpnTarget;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstanceBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.Vpn;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.SubnetsKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.napt.switches.RouterToNaptSwitchKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.Adjacencies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.AdjacenciesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInstances;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.VpnInterfaces;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.Adjacency.AdjacencyType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.adjacency.list.AdjacencyKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.VpnInstanceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.VpnInterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.interfaces.vpn._interface.VpnInstanceNames;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkAttributes.NetworkType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NetworkMaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.NeutronVpnPortipPortData;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.RouterInterfacesMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.networkmaps.NetworkMapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPort;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.neutron.vpn.portip.port.data.VpnPortipToPortKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.Subnetmap;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.subnetmaps.SubnetmapKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.ext.rev150712.NetworkL3Extension;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.NetworkKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets;
import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.SubnetKey;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.data.impl.schema.tree.SchemaValidationFailedException;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+@Singleton
public final class VpnUtil {
+
private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
- private static final int DEFAULT_PREFIX_LENGTH = 32;
- private static final String PREFIX_SEPARATOR = "/";
- private VpnUtil() {
+ public static final int SINGLE_TRANSACTION_BROKER_NO_RETRY = 1;
+ private static Boolean arpLearningEnabled = Boolean.TRUE;
+
+ private final DataBroker dataBroker;
+ private final IdManagerService idManager;
+ private final IFibManager fibManager;
+ private final IBgpManager bgpManager;
+ private final LockManagerService lockManager;
+ private final INeutronVpnManager neutronVpnService;
+ private final IMdsalApiManager mdsalManager;
+ private final IInterfaceManager interfaceManager;
+ private final JobCoordinator jobCoordinator;
+ private final ManagedNewTransactionRunner txRunner;
+ private final OdlInterfaceRpcService ifmRpcService;
+
+ /**
+ * Class to generate timestamps with microsecond precision.
+ * For example: MicroTimestamp.INSTANCE.get() = "2012-10-21 19:13:45.267128"
+ */
+ public enum MicroTimestamp {
+ INSTANCE ;
+
+ private long startDate ;
+ private long startNanoseconds ;
+ private SimpleDateFormat dateFormat ;
+
+ MicroTimestamp() {
+ this.startDate = System.currentTimeMillis() ;
+ this.startNanoseconds = System.nanoTime() ;
+ this.dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS") ;
+ }
+
+ public String get() {
+ long microSeconds = (System.nanoTime() - this.startNanoseconds) / 1000 ;
+ long date = this.startDate + microSeconds / 1000 ;
+ return this.dateFormat.format(date) + String.format("%03d", microSeconds % 1000) ;
+ }
}
- static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
+ public VpnUtil(DataBroker dataBroker, IdManagerService idManager, IFibManager fibManager,
+ IBgpManager bgpManager, LockManagerService lockManager, INeutronVpnManager neutronVpnService,
+ IMdsalApiManager mdsalManager, JobCoordinator jobCoordinator, IInterfaceManager interfaceManager,
+ OdlInterfaceRpcService ifmRpcService) {
+ this.dataBroker = dataBroker;
+ this.idManager = idManager;
+ this.fibManager = fibManager;
+ this.bgpManager = bgpManager;
+ this.lockManager = lockManager;
+ this.neutronVpnService = neutronVpnService;
+ this.mdsalManager = mdsalManager;
+ this.interfaceManager = interfaceManager;
+ this.jobCoordinator = jobCoordinator;
+ this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
+ this.ifmRpcService = ifmRpcService;
+ }
+
+ public static InstanceIdentifier<VpnInterface> getVpnInterfaceIdentifier(String vpnInterfaceName) {
return InstanceIdentifier.builder(VpnInterfaces.class)
- .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
+ .child(VpnInterface.class, new VpnInterfaceKey(vpnInterfaceName)).build();
}
- static InstanceIdentifier<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntryIdentifier(
- String vpnInterfaceName, String vpnName) {
- return InstanceIdentifier.builder(VpnInterfaceOpData.class)
- .child(VpnInterfaceOpDataEntry.class,
+ static InstanceIdentifier<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntryIdentifier(String vpnInterfaceName,
+ String vpnName) {
+ return InstanceIdentifier.builder(VpnInterfaceOpData.class).child(VpnInterfaceOpDataEntry.class,
new VpnInterfaceOpDataEntryKey(vpnInterfaceName, vpnName)).build();
}
static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
return InstanceIdentifier.builder(VpnInstances.class)
- .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
+ .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
}
- static VpnInterface getVpnInterface(DataBroker broker, String vpnInterfaceName) {
+ @Nullable
+ VpnInterface getVpnInterface(String vpnInterfaceName) {
InstanceIdentifier<VpnInterface> id = getVpnInterfaceIdentifier(vpnInterfaceName);
- Optional<VpnInterface> vpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInterface> vpnInterface = read(LogicalDatastoreType.CONFIGURATION, id);
return vpnInterface.isPresent() ? vpnInterface.get() : null;
}
- static VpnInterfaceOpDataEntry getVpnInterfaceOpDataEntry(String intfName, String vpnName,
- AdjacenciesOp aug, BigInteger dpnId,
- Boolean isSheduledForRemove, long lportTag, String gwMac) {
- return new VpnInterfaceOpDataEntryBuilder().setKey(new VpnInterfaceOpDataEntryKey(intfName, vpnName))
- .setDpnId(dpnId).setScheduledForRemove(isSheduledForRemove).addAugmentation(AdjacenciesOp.class, aug)
- .setLportTag(lportTag).setGatewayMacAddress(gwMac).build();
+ static VpnInterfaceOpDataEntry getVpnInterfaceOpDataEntry(String intfName, String vpnName, AdjacenciesOp aug,
+ Uint64 dpnId, long lportTag,
+ String gwMac, String gwIp) {
+ return new VpnInterfaceOpDataEntryBuilder().withKey(new VpnInterfaceOpDataEntryKey(intfName, vpnName))
+ .setDpnId(dpnId).addAugmentation(AdjacenciesOp.class, aug)
+ .setLportTag(lportTag).setGatewayMacAddress(gwMac).setGatewayIpAddress(gwIp).build();
}
- static Optional<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntry(DataBroker broker,
- String vpnInterfaceName, String vpnName) {
+ Optional<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntry(String vpnInterfaceName, String vpnName) {
InstanceIdentifier<VpnInterfaceOpDataEntry> id = getVpnInterfaceOpDataEntryIdentifier(vpnInterfaceName,
vpnName);
- Optional<VpnInterfaceOpDataEntry> vpnInterfaceOpDataEntry = read(broker,
- LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnInterfaceOpDataEntry> vpnInterfaceOpDataEntry = read(LogicalDatastoreType.OPERATIONAL,
+ id);
return vpnInterfaceOpDataEntry;
}
- static VpnInstanceNames getVpnInterfaceVpnInstanceNames(String vpnName, AssociatedSubnetType subnetType) {
- return new VpnInstanceNamesBuilder().setVpnName(vpnName).setAssociatedSubnetType(subnetType).build();
- }
-
- static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(long vpnId, String ipPrefix) {
- return InstanceIdentifier.builder(PrefixToInterface.class)
- .child(VpnIds.class, new VpnIdsKey(vpnId)).child(Prefixes.class,
- new PrefixesKey(ipPrefix)).build();
+ static InstanceIdentifier<Prefixes> getPrefixToInterfaceIdentifier(Uint32 vpnId, String ipPrefix) {
+ return InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId))
+ .child(Prefixes.class, new PrefixesKey(ipPrefix)).build();
}
- public static InstanceIdentifier<VpnIds> getPrefixToInterfaceIdentifier(long vpnId) {
- return InstanceIdentifier.builder(PrefixToInterface.class)
- .child(VpnIds.class, new VpnIdsKey(vpnId)).build();
+ static InstanceIdentifier<VpnIds> getPrefixToInterfaceIdentifier(Uint32 vpnId) {
+ return InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build();
}
- static VpnIds getPrefixToInterface(long vpnId) {
- return new VpnIdsBuilder().setKey(new VpnIdsKey(vpnId)).setVpnId(vpnId).build();
+ static Prefixes getPrefixToInterface(Uint64 dpId, String vpnInterfaceName, String ipPrefix,
+ Uuid networkId, NetworkType networkType, Long segmentationId, Prefixes.PrefixCue prefixCue) {
+ return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
+ vpnInterfaceName).setIpAddress(ipPrefix)//.setSubnetId(subnetId)
+ .setNetworkId(networkId).setNetworkType(networkType).setSegmentationId(segmentationId)
+ .setPrefixCue(prefixCue).build();
}
- static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix, Uuid subnetId,
+ static Prefixes getPrefixToInterface(Uint64 dpId, String vpnInterfaceName, String ipPrefix,
Prefixes.PrefixCue prefixCue) {
- return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
- vpnInterfaceName).setIpAddress(ipPrefix).setSubnetId(subnetId).setPrefixCue(prefixCue).build();
+ return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(vpnInterfaceName).setIpAddress(ipPrefix)
+ .setPrefixCue(prefixCue).build();
}
- static Optional<Prefixes> getPrefixToInterface(DataBroker broker, long vpnId, String ipPrefix) {
- return read(broker, LogicalDatastoreType.OPERATIONAL,
- getPrefixToInterfaceIdentifier(vpnId, getIpPrefix(ipPrefix)));
+ Optional<Prefixes> getPrefixToInterface(Uint32 vpnId, String ipPrefix) {
+ return read(LogicalDatastoreType.OPERATIONAL, getPrefixToInterfaceIdentifier(vpnId, getIpPrefix(ipPrefix)));
}
/**
* Get VRF table given a Route Distinguisher.
*
- * @param broker dataBroker service reference
* @param rd Route-Distinguisher
* @return VrfTables that holds the list of VrfEntries of the specified rd
*/
- public static VrfTables getVrfTable(DataBroker broker, String rd) {
- InstanceIdentifier<VrfTables> id =
- InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
- Optional<VrfTables> vrfTable = read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ @Nullable
+ VrfTables getVrfTable(String rd) {
+ InstanceIdentifier<VrfTables> id = InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class,
+ new VrfTablesKey(rd)).build();
+ Optional<VrfTables> vrfTable = read(LogicalDatastoreType.CONFIGURATION, id);
return vrfTable.isPresent() ? vrfTable.get() : null;
}
* Retrieves the VrfEntries that belong to a given VPN filtered out by
* Origin, searching by its Route-Distinguisher.
*
- * @param broker dataBroker service reference
* @param rd Route-distinguisher of the VPN
* @param originsToConsider Only entries whose origin is included in this list will be considered
* @return the list of VrfEntries
*/
- public static List<VrfEntry> getVrfEntriesByOrigin(DataBroker broker, String rd,
- List<RouteOrigin> originsToConsider) {
+ public List<VrfEntry> getVrfEntriesByOrigin(String rd, List<RouteOrigin> originsToConsider) {
List<VrfEntry> result = new ArrayList<>();
- List<VrfEntry> allVpnVrfEntries = getAllVrfEntries(broker, rd);
+ List<VrfEntry> allVpnVrfEntries = getAllVrfEntries(rd);
for (VrfEntry vrfEntry : allVpnVrfEntries) {
if (originsToConsider.contains(RouteOrigin.value(vrfEntry.getOrigin()))) {
result.add(vrfEntry);
return result;
}
- static List<Prefixes> getAllPrefixesToInterface(DataBroker broker, long vpnId) {
- Optional<VpnIds> vpnIds = read(broker, LogicalDatastoreType.OPERATIONAL, getPrefixToInterfaceIdentifier(vpnId));
- if (vpnIds.isPresent()) {
- return vpnIds.get().getPrefixes();
- }
- return new ArrayList<>();
- }
-
/**
* Retrieves all the VrfEntries that belong to a given VPN searching by its
* Route-Distinguisher.
*
- * @param broker dataBroker service reference
* @param rd Route-distinguisher of the VPN
* @return the list of VrfEntries
*/
- public static List<VrfEntry> getAllVrfEntries(DataBroker broker, String rd) {
- VrfTables vrfTables = VpnUtil.getVrfTable(broker, rd);
- return vrfTables != null ? vrfTables.getVrfEntry() : new ArrayList<>();
+ public List<VrfEntry> getAllVrfEntries(String rd) {
+ VrfTables vrfTables = getVrfTable(rd);
+ if (vrfTables != null && vrfTables.getVrfEntry() != null) {
+ return vrfTables.getVrfEntry();
+ }
+ return emptyList();
}
//FIXME: Implement caches for DS reads
- public static VpnInstance getVpnInstance(DataBroker broker, String vpnInstanceName) {
+ @Nullable
+ public VpnInstance getVpnInstance(String vpnInstanceName) {
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,
new VpnInstanceKey(vpnInstanceName)).build();
- Optional<VpnInstance> vpnInstance = read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
return vpnInstance.isPresent() ? vpnInstance.get() : null;
}
- public static List<VpnInstanceOpDataEntry> getAllVpnInstanceOpData(DataBroker broker) {
- InstanceIdentifier<VpnInstanceOpData> id = InstanceIdentifier.builder(VpnInstanceOpData.class).build();
- Optional<VpnInstanceOpData> vpnInstanceOpDataOptional =
- VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, id);
- if (vpnInstanceOpDataOptional.isPresent()) {
- return vpnInstanceOpDataOptional.get().getVpnInstanceOpDataEntry();
- } else {
- return new ArrayList<>();
+ @NonNull
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ List<VpnInstanceOpDataEntry> getAllVpnInstanceOpData() {
+ try {
+ InstanceIdentifier<VpnInstanceOpData> id = InstanceIdentifier.builder(VpnInstanceOpData.class).build();
+ Optional<VpnInstanceOpData> vpnInstanceOpDataOptional = read(LogicalDatastoreType.OPERATIONAL, id);
+ return
+ vpnInstanceOpDataOptional.isPresent() && vpnInstanceOpDataOptional.get()
+ .getVpnInstanceOpDataEntry() != null ? vpnInstanceOpDataOptional.get()
+ .getVpnInstanceOpDataEntry() : emptyList();
+ } catch (Exception e) {
+ LOG.error("getAllVpnInstanceOpData: Could not retrieve all vpn instance op data subtree...", e);
+ return emptyList();
}
}
- public static List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn
- .instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> getDpnVpnInterfaces(DataBroker broker,
- VpnInstance vpnInstance, BigInteger dpnId) {
+ @NonNull
+ List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data
+ .vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces> getDpnVpnInterfaces(VpnInstance vpnInstance,
+ Uint64 dpnId) {
String primaryRd = getPrimaryRd(vpnInstance);
- InstanceIdentifier<VpnToDpnList> dpnToVpnId = getVpnToDpnListIdentifier(primaryRd, dpnId);
- Optional<VpnToDpnList> dpnInVpn = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
- return dpnInVpn.isPresent() ? dpnInVpn.get().getVpnInterfaces() : Collections.emptyList();
+ InstanceIdentifier<VpnToDpnList> dpnToVpnId = VpnHelper.getVpnToDpnListIdentifier(primaryRd, dpnId);
+ Optional<VpnToDpnList> dpnInVpn = read(LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
+ return dpnInVpn.isPresent() && dpnInVpn.get().getVpnInterfaces() != null ? dpnInVpn.get().getVpnInterfaces()
+ : emptyList();
}
- public static List<String> getListOfRdsFromVpnInstance(VpnInstance vpnInstance) {
- VpnAfConfig vpnConfig = vpnInstance.getIpv4Family();
- LOG.trace("vpnConfig {}", vpnConfig);
- return vpnConfig.getRouteDistinguisher() != null ? new ArrayList<>(
- vpnConfig.getRouteDistinguisher()) : new ArrayList<>();
+ @NonNull
+ static List<String> getListOfRdsFromVpnInstance(VpnInstance vpnInstance) {
+ return vpnInstance.getRouteDistinguisher() != null ? new ArrayList<>(
+ vpnInstance.getRouteDistinguisher()) : new ArrayList<>();
}
- static VrfEntry getVrfEntry(DataBroker broker, String rd, String ipPrefix) {
-
- VrfTables vrfTable = getVrfTable(broker, rd);
+ @Nullable
+ VrfEntry getVrfEntry(String rd, String ipPrefix) {
+ VrfTables vrfTable = getVrfTable(rd);
// TODO: why check VrfTables if we later go for the specific VrfEntry?
if (vrfTable != null) {
InstanceIdentifier<VrfEntry> vrfEntryId =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
VrfEntry.class, new VrfEntryKey(ipPrefix)).build();
- Optional<VrfEntry> vrfEntry = read(broker, LogicalDatastoreType.CONFIGURATION, vrfEntryId);
+ Optional<VrfEntry> vrfEntry = read(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
if (vrfEntry.isPresent()) {
return vrfEntry.get();
}
return null;
}
- static List<Adjacency> getAdjacenciesForVpnInterfaceFromConfig(DataBroker broker, String intfName) {
+ @Nullable
+ public List<Adjacency> getAdjacenciesForVpnInterfaceFromConfig(String intfName) {
final InstanceIdentifier<VpnInterface> identifier = getVpnInterfaceIdentifier(intfName);
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
- Optional<Adjacencies> adjacencies = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, path);
-
+ Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.CONFIGURATION, path);
if (adjacencies.isPresent()) {
- List<Adjacency> nextHops = adjacencies.get().getAdjacency();
- return nextHops;
+ return adjacencies.get().getAdjacency();
}
return null;
}
- static Routes getVpnToExtraroute(String ipPrefix, List<String> nextHopList) {
+ static Routes getVpnToExtraroute(String ipPrefix, List<String> nextHopList) {
return new RoutesBuilder().setPrefix(ipPrefix).setNexthopIpList(nextHopList).build();
}
- static String getVpnInterfaceName(OdlInterfaceRpcService odlInterfaceRpcService, BigInteger metadata)
- throws InterruptedException, ExecutionException {
+ @Nullable
+ String getVpnInterfaceName(Uint64 metadata) throws InterruptedException, ExecutionException {
GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
- BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata);
+ Uint64 lportTag = MetaDataUtil.getLportFromMetadata(metadata);
ifIndexInputBuilder.setIfIndex(lportTag.intValue());
GetInterfaceFromIfIndexInput input = ifIndexInputBuilder.build();
Future<RpcResult<GetInterfaceFromIfIndexOutput>> interfaceFromIfIndex =
- odlInterfaceRpcService.getInterfaceFromIfIndex(input);
+ ifmRpcService.getInterfaceFromIfIndex(input);
GetInterfaceFromIfIndexOutput interfaceFromIfIndexOutput;
RpcResult<GetInterfaceFromIfIndexOutput> rpcResult = interfaceFromIfIndex.get();
if (rpcResult == null) {
}
static AllocatedRdsBuilder getRdsBuilder(String nexthop, String rd) {
- return new AllocatedRdsBuilder().setKey(new AllocatedRdsKey(nexthop)).setNexthop(nexthop).setRd(rd);
+ return new AllocatedRdsBuilder().withKey(new AllocatedRdsKey(nexthop)).setNexthop(nexthop).setRd(rd);
}
- static Adjacencies getVpnInterfaceAugmentation(List<Adjacency> nextHopList) {
+
public static Adjacencies getVpnInterfaceAugmentation(List<Adjacency> nextHopList) {
return new AdjacenciesBuilder().setAdjacency(nextHopList).build();
}
return new AdjacenciesOpBuilder().setAdjacency(nextHopList).build();
}
- public static InstanceIdentifier<IdPool> getPoolId(String poolName) {
- InstanceIdentifier.InstanceIdentifierBuilder<IdPool> idBuilder =
- InstanceIdentifier.builder(IdPools.class).child(IdPool.class, new IdPoolKey(poolName));
- return idBuilder.build();
- }
-
- static InstanceIdentifier<VpnInterfaces> getVpnInterfacesIdentifier() {
- return InstanceIdentifier.builder(VpnInterfaces.class).build();
- }
-
static InstanceIdentifier<Interface> getInterfaceIdentifier(String interfaceName) {
- return InstanceIdentifier.builder(Interfaces.class)
- .child(Interface.class, new InterfaceKey(interfaceName)).build();
+ return InstanceIdentifier.builder(Interfaces.class).child(Interface.class,
+ new InterfaceKey(interfaceName)).build();
}
- static InstanceIdentifier<VpnToDpnList> getVpnToDpnListIdentifier(String rd, BigInteger dpnId) {
- return InstanceIdentifier.builder(VpnInstanceOpData.class)
- .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd))
- .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId)).build();
- }
-
- public static BigInteger getCookieArpFlow(int interfaceTag) {
- return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0110000", 16)).add(
- BigInteger.valueOf(interfaceTag));
+ public static Uint64 getCookieL3(int vpnId) {
+ return Uint64.valueOf(VpnConstants.COOKIE_L3_BASE.toJava().add(new BigInteger("0610000", 16))
+ .add(BigInteger.valueOf(vpnId)));
}
- public static BigInteger getCookieL3(int vpnId) {
- return VpnConstants.COOKIE_L3_BASE.add(new BigInteger("0610000", 16)).add(BigInteger.valueOf(vpnId));
- }
-
- public static String getFlowRef(BigInteger dpnId, short tableId, int ethType, int lportTag, int arpType) {
- return new StringBuffer().append(VpnConstants.FLOWID_PREFIX).append(dpnId).append(NwConstants.FLOWID_SEPARATOR)
- .append(tableId).append(NwConstants.FLOWID_SEPARATOR).append(ethType).append(lportTag)
- .append(NwConstants.FLOWID_SEPARATOR).append(arpType).toString();
- }
-
- public static int getUniqueId(IdManagerService idManager, String poolName, String idKey) {
+ public Uint32 getUniqueId(String poolName, String idKey) {
AllocateIdInput getIdInput = new AllocateIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
-
try {
Future<RpcResult<AllocateIdOutput>> result = idManager.allocateId(getIdInput);
RpcResult<AllocateIdOutput> rpcResult = result.get();
if (rpcResult.isSuccessful()) {
- return rpcResult.getResult().getIdValue().intValue();
+ return rpcResult.getResult().getIdValue();
} else {
LOG.error("getUniqueId: RPC Call to Get Unique Id from pool {} with key {} returned with Errors {}",
poolName, idKey, rpcResult.getErrors());
} catch (InterruptedException | ExecutionException e) {
LOG.error("getUniqueId: Exception when getting Unique Id from pool {} for key {}", poolName, idKey, e);
}
- return 0;
+ return Uint32.ZERO;
}
- public static void releaseId(IdManagerService idManager, String poolName, String idKey) {
+ void releaseId(String poolName, String idKey) {
ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
try {
- Future<RpcResult<Void>> result = idManager.releaseId(idInput);
- RpcResult<Void> rpcResult = result.get();
+ RpcResult<ReleaseIdOutput> rpcResult = idManager.releaseId(idInput).get();
if (!rpcResult.isSuccessful()) {
LOG.error("releaseId: RPC Call to release Id for key {} from pool {} returned with Errors {}",
idKey, poolName, rpcResult.getErrors());
return rd + VpnConstants.SEPARATOR + prefix;
}
- /**
- * Retrieves the VpnInstance name (typically the VPN Uuid) out from the
- * route-distinguisher.
- *
- * @param broker dataBroker service reference
- * @param rd Route-Distinguisher
- * @return the VpnInstance name
- */
- public static String getVpnNameFromRd(DataBroker broker, String rd) {
- VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(broker, rd);
- return vpnInstanceOpData != null ? vpnInstanceOpData.getVpnInstanceName() : null;
- }
-
/**
* Retrieves the dataplane identifier of a specific VPN, searching by its
* VpnInstance name.
*
- * @param broker dataBroker service reference
* @param vpnName Name of the VPN
* @return the dataplane identifier of the VPN, the VrfTag.
*/
- public static long getVpnId(DataBroker broker, String vpnName) {
+ public Uint32 getVpnId(String vpnName) {
if (vpnName == null) {
return VpnConstants.INVALID_ID;
}
- return read(broker, LogicalDatastoreType.CONFIGURATION,
- VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName)).toJavaUtil().map(
- org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance::getVpnId).orElse(VpnConstants.INVALID_ID);
- }
-
- public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance
- .to.vpn.id.VpnInstance> getVpnInstanceToVpnIdIdentifier(
- String vpnName) {
- return InstanceIdentifier.builder(VpnInstanceToVpnId.class)
- .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn
- .id.VpnInstanceKey(
- vpnName))
- .build();
+ return read(LogicalDatastoreType.CONFIGURATION, VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName))
+ .toJavaUtil().map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
+ .vpn.instance.to.vpn.id.VpnInstance::getVpnId)
+ .orElse(VpnConstants.INVALID_ID);
}
/**
* Retrieves the VPN Route Distinguisher searching by its Vpn instance name.
*
- * @param broker dataBroker service reference
* @param vpnName Name of the VPN
* @return the route-distinguisher of the VPN
*/
- public static String getVpnRd(DataBroker broker, String vpnName) {
+ public String getVpnRd(String vpnName) {
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance>
- vpnInstance
- = read(broker, LogicalDatastoreType.CONFIGURATION, VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
-
+ .VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION,
+ VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
String rd = null;
if (vpnInstance.isPresent()) {
rd = vpnInstance.get().getVrfId();
return rd;
}
- private static List<String> getVpnRdsFromVpnInstanceConfig(DataBroker broker, String vpnName) {
+ public static String getVpnRd(TypedReadTransaction<Configuration> confTx, String vpnName) {
+ try {
+ return confTx.read(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName)).get().toJavaUtil().map(
+ vpnInstance -> vpnInstance.getVrfId()).orElse(null);
+ } catch (InterruptedException | ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ List<String> getVpnRdsFromVpnInstanceConfig(String vpnName) {
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
- Optional<VpnInstance> vpnInstance = VpnUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
return vpnInstance.isPresent() ? getListOfRdsFromVpnInstance(vpnInstance.get()) : new ArrayList<>();
}
/**
* Remove from MDSAL all those VrfEntries in a VPN that have an specific RouteOrigin.
*
- * @param broker dataBroker service reference
* @param rd Route Distinguisher
* @param origin Origin of the Routes to be removed (see {@link RouteOrigin})
*/
- public static void removeVrfEntriesByOrigin(DataBroker broker, String rd, RouteOrigin origin) {
+ public void removeVrfEntriesByOrigin(String rd, RouteOrigin origin) {
InstanceIdentifier<VrfTables> vpnVrfTableIid =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
- Optional<VrfTables> vrfTablesOpc = read(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
+ Optional<VrfTables> vrfTablesOpc = read(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
if (vrfTablesOpc.isPresent()) {
VrfTables vrfTables = vrfTablesOpc.get();
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
- if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
- tx.delete(LogicalDatastoreType.CONFIGURATION,
- vpnVrfTableIid.child(VrfEntry.class, vrfEntry.getKey()));
- }
- }
- tx.submit();
+ ListenableFutures.addErrorLogging(
+ new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
+ Datastore.CONFIGURATION, tx -> {
+ for (VrfEntry vrfEntry : vrfTables.nonnullVrfEntry()) {
+ if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
+ tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
+ }
+ }
+ }), LOG, "Error removing VRF entries by origin");
}
}
- public static List<VrfEntry> findVrfEntriesByNexthop(DataBroker broker, String rd, String nexthop) {
+ public List<VrfEntry> findVrfEntriesByNexthop(String rd, String nexthop) {
InstanceIdentifier<VrfTables> vpnVrfTableIid =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
- Optional<VrfTables> vrfTablesOpc = read(broker, LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
+ Optional<VrfTables> vrfTablesOpc = read(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
List<VrfEntry> matches = new ArrayList<>();
-
if (vrfTablesOpc.isPresent()) {
VrfTables vrfTables = vrfTablesOpc.get();
- for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
- vrfEntry.getRoutePaths().stream()
- .filter(routePath -> routePath.getNexthopAddress() != null
- && routePath.getNexthopAddress().equals(nexthop))
- .findFirst().ifPresent(routePath -> matches.add(vrfEntry));
+ for (VrfEntry vrfEntry : vrfTables.nonnullVrfEntry()) {
+ vrfEntry.nonnullRoutePaths().stream()
+ .filter(routePath -> routePath.getNexthopAddress() != null && routePath.getNexthopAddress()
+ .equals(nexthop)).findFirst().ifPresent(routePath -> matches.add(vrfEntry));
}
}
return matches;
}
- public static void removeVrfEntries(DataBroker broker, String rd, List<VrfEntry> vrfEntries) {
+ public void removeVrfEntries(String rd, List<VrfEntry> vrfEntries) {
InstanceIdentifier<VrfTables> vpnVrfTableIid =
InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- for (VrfEntry vrfEntry : vrfEntries) {
- tx.delete(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid.child(VrfEntry.class, vrfEntry.getKey()));
- }
- tx.submit();
+ ListenableFutures.addErrorLogging(
+ new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
+ Datastore.CONFIGURATION, tx -> {
+ for (VrfEntry vrfEntry : vrfEntries) {
+ tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
+ }
+ }), LOG, "Error removing VRF entries");
}
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public static void withdrawRoutes(IBgpManager bgpManager, String rd, List<VrfEntry> vrfEntries) {
+ public void withdrawRoutes(String rd, List<VrfEntry> vrfEntries) {
vrfEntries.forEach(vrfEntry -> {
try {
bgpManager.withdrawPrefix(rd, vrfEntry.getDestPrefix());
});
}
+ public boolean removeOrUpdateDSForExtraRoute(String vpnName, String primaryRd, String extraRouteRd,
+ String vpnInterfaceName, String prefix, String nextHop,
+ String nextHopTunnelIp, TypedWriteTransaction<Operational> operTx) {
+ LOG.info("removeOrUpdateDSForExtraRoute: VPN WITHDRAW: Removing Fib Entry rd {} prefix {} nexthop {}",
+ extraRouteRd, prefix, nextHop);
+ boolean areNextHopsClearedForRd = false;
+ Optional<Routes> optVpnExtraRoutes = VpnExtraRouteHelper
+ .getVpnExtraroutes(dataBroker, vpnName, extraRouteRd, prefix);
+ if (optVpnExtraRoutes.isPresent()) {
+ List<String> nhList = optVpnExtraRoutes.get().getNexthopIpList();
+ if (nhList != null && nhList.size() > 1) {
+ // If nhList is more than 1, just update vpntoextraroute and prefixtointerface DS
+ // For other cases, remove the corresponding tep ip from fibentry and withdraw prefix
+ nhList.remove(nextHop);
+ syncWrite(LogicalDatastoreType.OPERATIONAL,
+ VpnExtraRouteHelper.getVpnToExtrarouteVrfIdIdentifier(vpnName, extraRouteRd, prefix),
+ VpnUtil.getVpnToExtraroute(prefix, nhList));
+ MDSALUtil.syncDelete(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, VpnExtraRouteHelper.getUsedRdsIdentifier(getVpnId(vpnName),
+ prefix, nextHop));
+ LOG.info("removeOrUpdateDSForExtraRoute: Removed vpn-to-extraroute with rd {} prefix {} nexthop {}",
+ extraRouteRd, prefix, nextHop);
+ fibManager.refreshVrfEntry(primaryRd, prefix);
+ operTx.delete(VpnUtil.getVpnInterfaceOpDataEntryAdjacencyIdentifier(vpnInterfaceName, vpnName, prefix));
+ LOG.info("VPN WITHDRAW: removeOrUpdateDSForExtraRoute: Removed Fib Entry rd {} prefix {} nexthop {}",
+ extraRouteRd, prefix, nextHopTunnelIp);
+ areNextHopsClearedForRd = true;
+ }
+ }
+ return areNextHopsClearedForRd;
+ }
+
static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id.VpnInstance
- getVpnInstanceToVpnId(String vpnName, long vpnId, String rd) {
+ getVpnInstanceToVpnId(String vpnName, Uint32 vpnId, String rd) {
return new VpnInstanceBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
}
- static RouterInterface getConfiguredRouterInterface(DataBroker broker, String interfaceName) {
- Optional<RouterInterface> optRouterInterface =
- read(broker, LogicalDatastoreType.CONFIGURATION, VpnUtil.getRouterInterfaceId(interfaceName));
- if (optRouterInterface.isPresent()) {
- return optRouterInterface.get();
- }
- return null;
- }
-
static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
- getVpnIdToVpnInstance(long vpnId, String vpnName, String rd, boolean isExternalVpn) {
+ getVpnIdToVpnInstance(Uint32 vpnId, String vpnName, String rd, boolean isExternalVpn) {
return new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
- .VpnIdsBuilder()
- .setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).setExternalVpn(isExternalVpn).build();
+ .VpnIdsBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).setExternalVpn(isExternalVpn)
+ .build();
}
- public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to
- .vpn.instance.VpnIds>
- getVpnIdToVpnInstanceIdentifier(long vpnId) {
- return InstanceIdentifier.builder(VpnIdToVpnInstance.class)
- .child(
- org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
- .class,
+ static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to
+ .vpn.instance.VpnIds> getVpnIdToVpnInstanceIdentifier(Uint32 vpnId) {
+ return InstanceIdentifier.builder(VpnIdToVpnInstance.class).child(org.opendaylight.yang.gen.v1.urn
+ .opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds.class,
new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
.VpnIdsKey(vpnId)).build();
}
/**
* Retrieves the Vpn Name searching by its VPN Tag.
*
- * @param broker dataBroker service reference
* @param vpnId Dataplane identifier of the VPN
* @return the Vpn instance name
*/
- public static String getVpnName(DataBroker broker, long vpnId) {
+ @Nullable
+ String getVpnName(Uint32 vpnId) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
- .instance.VpnIds>
- id
- = getVpnIdToVpnInstanceIdentifier(vpnId);
+ .instance.VpnIds> id = getVpnIdToVpnInstanceIdentifier(vpnId);
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
vpnInstance
- = read(broker, LogicalDatastoreType.CONFIGURATION, id);
-
+ = read(LogicalDatastoreType.CONFIGURATION, id);
String vpnName = null;
if (vpnInstance.isPresent()) {
vpnName = vpnInstance.get().getVpnInstanceName();
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
}
- static InstanceIdentifier<RouterInterface> getRouterInterfaceId(String interfaceName) {
- return InstanceIdentifier.builder(RouterInterfaces.class)
- .child(RouterInterface.class, new RouterInterfaceKey(interfaceName)).build();
+ @Nullable
+ public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd) {
+ return read(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(rd)).orNull();
}
- static RouterInterface getRouterInterface(String interfaceName, String routerName) {
- return new RouterInterfaceBuilder().setKey(new RouterInterfaceKey(interfaceName))
- .setInterfaceName(interfaceName).setRouterName(routerName).build();
- }
-
- public static VpnInstanceOpDataEntry getVpnInstanceOpData(DataBroker broker, String rd) {
- InstanceIdentifier<VpnInstanceOpDataEntry> id = VpnUtil.getVpnInstanceOpDataIdentifier(rd);
- return read(broker, LogicalDatastoreType.OPERATIONAL, id).orNull();
- }
-
- static VpnInterface getConfiguredVpnInterface(DataBroker broker, String interfaceName) {
+ @Nullable
+ VpnInterface getConfiguredVpnInterface(String interfaceName) {
InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
- Optional<VpnInterface> configuredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId);
-
+ Optional<VpnInterface> configuredVpnInterface = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
if (configuredVpnInterface.isPresent()) {
return configuredVpnInterface.get();
}
return null;
}
- static String getNeutronRouterFromInterface(DataBroker broker, String interfaceName) {
- InstanceIdentifier.InstanceIdentifierBuilder<RouterInterfacesMap> idBuilder =
- InstanceIdentifier.builder(RouterInterfacesMap.class);
- InstanceIdentifier<RouterInterfacesMap> id = idBuilder.build();
- Optional<RouterInterfacesMap> routerInterfacesMap =
- MDSALUtil.read(broker, LogicalDatastoreType.CONFIGURATION, id);
- if (routerInterfacesMap.isPresent()) {
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
- .RouterInterfaces>
- rtrInterfaces = routerInterfacesMap.get().getRouterInterfaces();
- for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
- .RouterInterfaces rtrInterface : rtrInterfaces) {
- List<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
- .router.interfaces.Interfaces>
- rtrIfc = rtrInterface.getInterfaces();
- for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.router.interfaces.map
- .router.interfaces.Interfaces ifc : rtrIfc) {
- if (ifc.getInterfaceId().equals(interfaceName)) {
- return rtrInterface.getRouterId().getValue();
- }
- }
- }
- }
- return null;
- }
-
- static boolean isVpnInterfaceConfigured(DataBroker broker, String interfaceName) {
+ boolean isVpnInterfaceConfigured(String interfaceName) {
InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
- return read(broker, LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent();
+ return read(LogicalDatastoreType.CONFIGURATION, interfaceId).isPresent();
}
- static Optional<List<String>> getVpnHandlingIpv4AssociatedWithInterface(DataBroker broker, String interfaceName) {
+ public Optional<List<String>> getVpnHandlingIpv4AssociatedWithInterface(String interfaceName) {
InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
Optional<List<String>> vpnOptional = Optional.absent();
- Optional<VpnInterface> optConfiguredVpnInterface = read(broker, LogicalDatastoreType.CONFIGURATION,
- interfaceId);
+ Optional<VpnInterface> optConfiguredVpnInterface = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
if (optConfiguredVpnInterface.isPresent()) {
VpnInterface cfgVpnInterface = optConfiguredVpnInterface.get();
java.util.Optional<List<VpnInstanceNames>> optVpnInstanceList =
if (optVpnInstanceList.isPresent()) {
List<String> vpnList = new ArrayList<>();
for (VpnInstanceNames vpnInstance : optVpnInstanceList.get()) {
- if (vpnInstance.getAssociatedSubnetType().equals(AssociatedSubnetType.V6Subnet)) {
- continue;
- }
vpnList.add(vpnInstance.getVpnName());
}
vpnOptional = Optional.of(vpnList);
}
public static String getIpPrefix(String prefix) {
- String[] prefixValues = prefix.split("/");
- if (prefixValues.length == 1) {
- prefix = prefix + PREFIX_SEPARATOR + DEFAULT_PREFIX_LENGTH;
- }
- return prefix;
+ return prefix.indexOf('/') != -1 ? prefix : NWUtil.toIpPrefix(prefix);
}
static final FutureCallback<Void> DEFAULT_CALLBACK =
};
- public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) {
- try (ReadOnlyTransaction tx = broker.newReadOnlyTransaction()) {
- return tx.read(datastoreType, path).get();
- } catch (InterruptedException | ExecutionException e) {
- throw new RuntimeException(e);
- }
- }
-
- public static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data) {
- asyncUpdate(broker, datastoreType, path, data, DEFAULT_CALLBACK);
- }
-
- public static <T extends DataObject> void asyncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.merge(datastoreType, path, data, true);
- Futures.addCallback(tx.submit(), callback, MoreExecutors.directExecutor());
- }
-
- public static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data) {
- asyncWrite(broker, datastoreType, path, data, DEFAULT_CALLBACK);
- }
-
- public static <T extends DataObject> void asyncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.put(datastoreType, path, data, WriteTransaction.CREATE_MISSING_PARENTS);
- Futures.addCallback(tx.submit(), callback, MoreExecutors.directExecutor());
- }
-
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- public static <T extends DataObject> void tryDelete(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) {
+ @Deprecated
+ private <T extends DataObject> Optional<T> read(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path) {
try {
- delete(broker, datastoreType, path, DEFAULT_CALLBACK);
- } catch (SchemaValidationFailedException sve) {
- LOG.info("tryDelete: Could not delete {}. SchemaValidationFailedException: {}", path, sve.getMessage());
- } catch (Exception e) {
- LOG.info("tryDelete: Could not delete {}. Unhandled error: {}", path, e.getMessage());
+ return SingleTransactionDataBroker.syncReadOptional(dataBroker, datastoreType, path);
+ } catch (ReadFailedException e) {
+ throw new RuntimeException(e);
}
}
- public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path) {
- delete(broker, datastoreType, path, DEFAULT_CALLBACK);
- }
-
-
- public static <T extends DataObject> void delete(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, FutureCallback<Void> callback) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.delete(datastoreType, path);
- Futures.addCallback(tx.submit(), callback, MoreExecutors.directExecutor());
- }
-
- public static <T extends DataObject> void syncWrite(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.put(datastoreType, path, data, WriteTransaction.CREATE_MISSING_PARENTS);
-
+ @Deprecated
+ public <T extends DataObject> void syncWrite(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path,
+ T data) {
try {
- tx.submit().get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("syncWrite: Error writing to datastore (path, data) : ({}, {})", path, data);
+ SingleTransactionDataBroker.syncWrite(dataBroker, datastoreType, path, data);
+ } catch (TransactionCommitFailedException e) {
+ LOG.error("syncWrite: Error writing to datastore (path, data) : ({}, {})", path, data, e);
throw new RuntimeException(e.getMessage(), e);
}
}
- public static <T extends DataObject> void syncUpdate(DataBroker broker, LogicalDatastoreType datastoreType,
- InstanceIdentifier<T> path, T data) {
- WriteTransaction tx = broker.newWriteOnlyTransaction();
- tx.merge(datastoreType, path, data, true);
-
+ @Deprecated
+ public <T extends DataObject> void syncUpdate(LogicalDatastoreType datastoreType, InstanceIdentifier<T> path,
+ T data) {
try {
- tx.submit().get();
- } catch (InterruptedException | ExecutionException e) {
- LOG.error("syncUpdate: Error writing to datastore (path, data) : ({}, {})", path, data);
+ SingleTransactionDataBroker.syncUpdate(dataBroker, datastoreType, path, data);
+ } catch (TransactionCommitFailedException e) {
+ LOG.error("syncUpdate: Error writing to datastore (path, data) : ({}, {})", path, data, e);
throw new RuntimeException(e.getMessage(), e);
}
}
- public static long getRemoteBCGroup(long elanTag) {
+ static long getRemoteBCGroup(long elanTag) {
return VpnConstants.ELAN_GID_MIN + elanTag % VpnConstants.ELAN_GID_MIN * 2;
}
// interface-index-tag operational container
- public static IfIndexInterface getInterfaceInfoByInterfaceTag(DataBroker broker, long interfaceTag) {
+ @Nullable
+ IfIndexInterface getInterfaceInfoByInterfaceTag(long interfaceTag) {
InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
- Optional<IfIndexInterface> existingInterfaceInfo =
- VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, interfaceId);
+ Optional<IfIndexInterface> existingInterfaceInfo = read(LogicalDatastoreType.OPERATIONAL, interfaceId);
if (existingInterfaceInfo.isPresent()) {
return existingInterfaceInfo.get();
}
return null;
}
- private static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
+ static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
return InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class,
new IfIndexInterfaceKey((int) interfaceTag)).build();
}
- public static ElanTagName getElanInfoByElanTag(DataBroker broker, long elanTag) {
+ @Nullable
+ ElanTagName getElanInfoByElanTag(long elanTag) {
InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
- Optional<ElanTagName> existingElanInfo = VpnUtil.read(broker, LogicalDatastoreType.OPERATIONAL, elanId);
+ Optional<ElanTagName> existingElanInfo = read(LogicalDatastoreType.OPERATIONAL, elanId);
if (existingElanInfo.isPresent()) {
return existingElanInfo.get();
}
return null;
}
- private static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
+ static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
return InstanceIdentifier.builder(ElanTagNameMap.class).child(ElanTagName.class,
new ElanTagNameKey(elanTag)).build();
}
- /**
- * Returns the Path identifier to reach a specific interface in a specific DPN in a given VpnInstance.
- *
- * @param vpnRd Route-Distinguisher of the VpnInstance
- * @param dpnId Id of the DPN where the interface is
- * @param ifaceName Interface name
- * @return the Instance Identifier
- */
- public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
- .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces>
- getVpnToDpnInterfacePath(String vpnRd, BigInteger dpnId, String ifaceName) {
-
- return
- InstanceIdentifier.builder(VpnInstanceOpData.class)
- .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(vpnRd))
- .child(VpnToDpnList.class, new VpnToDpnListKey(dpnId))
- .child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
- .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces.class,
- new org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn
- .instance.op.data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfacesKey(ifaceName))
- .build();
+ static void removePrefixToInterfaceForVpnId(Uint32 vpnId, @NonNull TypedWriteTransaction<Operational> operTx) {
+ // Clean up PrefixToInterface Operational DS
+ operTx.delete(InstanceIdentifier.builder(
+ PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build());
+ }
+
+ static void removeVpnExtraRouteForVpn(String vpnName, @NonNull TypedWriteTransaction<Operational> operTx) {
+ // Clean up VPNExtraRoutes Operational DS
+ operTx.delete(InstanceIdentifier.builder(VpnToExtraroutes.class).child(Vpn.class, new VpnKey(vpnName)).build());
}
- // TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public static void removePrefixToInterfaceForVpnId(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
- try {
- // Clean up PrefixToInterface Operational DS
- if (writeTxn != null) {
- writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(PrefixToInterface.class).child(
- VpnIds.class, new VpnIdsKey(vpnId)).build());
- } else {
- delete(broker, LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class,
- new VpnIdsKey(vpnId)).build(),
- DEFAULT_CALLBACK);
- }
- } catch (Exception e) {
- LOG.error("removePrefixToInterfaceForVpnId: Exception during cleanup of PrefixToInterface for VPN ID {}",
- vpnId, e);
+ static void removeVpnOpInstance(String vpnName, @NonNull TypedWriteTransaction<Operational> operTx) {
+ // Clean up VPNInstanceOpDataEntry
+ operTx.delete(getVpnInstanceOpDataIdentifier(vpnName));
+ }
+
+ static void removeVpnInstanceToVpnId(String vpnName, @NonNull TypedWriteTransaction<Configuration> confTx) {
+ confTx.delete(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
+ }
+
+ static void removeVpnIdToVpnInstance(Uint32 vpnId, @NonNull TypedWriteTransaction<Configuration> confTx) {
+ confTx.delete(getVpnIdToVpnInstanceIdentifier(vpnId));
+ }
+
+ static void removeL3nexthopForVpnId(Uint32 vpnId, @NonNull TypedWriteTransaction<Operational> operTx) {
+ // Clean up L3NextHop Operational DS
+ operTx.delete(InstanceIdentifier.builder(L3nexthop.class).child(
+ VpnNexthops.class, new VpnNexthopsKey(vpnId)).build());
+ }
+
+ void scheduleVpnInterfaceForRemoval(String interfaceName, Uint64 dpnId, String vpnInstanceName,
+ @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
+ InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
+ getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnInstanceName);
+ VpnInterfaceOpDataEntry interfaceToUpdate =
+ new VpnInterfaceOpDataEntryBuilder().withKey(new VpnInterfaceOpDataEntryKey(interfaceName,
+ vpnInstanceName)).setName(interfaceName).setDpnId(dpnId).setVpnInstanceName(vpnInstanceName)
+ .build();
+ if (writeOperTxn != null) {
+ writeOperTxn.merge(interfaceId, interfaceToUpdate, true);
+ } else {
+ syncUpdate(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate);
}
}
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- public static void removeVpnExtraRouteForVpn(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
+ public void createLearntVpnVipToPort(String vpnName, String fixedIp, String portName, String macAddress,
+ TypedWriteTransaction<Operational> writeOperTxn) {
+ final InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
+ final ReentrantLock lock = lockFor(vpnName, fixedIp);
+ lock.lock();
try {
- // Clean up VPNExtraRoutes Operational DS
- if (writeTxn != null) {
- writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(VpnToExtraroutes.class)
- .child(Vpn.class, new VpnKey(vpnName)).build());
+ LearntVpnVipToPortBuilder builder =
+ new LearntVpnVipToPortBuilder().withKey(new LearntVpnVipToPortKey(fixedIp, vpnName)).setVpnName(
+ vpnName).setPortFixedip(fixedIp).setPortName(portName)
+ .setMacAddress(macAddress.toLowerCase(Locale.getDefault()))
+ .setCreationTime(new SimpleDateFormat("MM/dd/yyyy h:mm:ss a").format(new Date()));
+ if (writeOperTxn != null) {
+ writeOperTxn.put(id, builder.build(), true);
} else {
- delete(broker, LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(VpnToExtraroutes.class)
- .child(Vpn.class, new VpnKey(vpnName)).build(),
- DEFAULT_CALLBACK);
+ syncWrite(LogicalDatastoreType.OPERATIONAL, id, builder.build());
}
- } catch (Exception e) {
- LOG.error("removeVpnExtraRouteForVpna: Exception during cleanup of VPNToExtraRoute for VPN {}",
- vpnName, e);
+ LOG.debug("createLearntVpnVipToPort: ARP/NA learned for fixedIp: {}, vpn {}, interface {}, mac {},"
+ + " added to LearntVpnVipToPort DS", fixedIp, vpnName, portName, macAddress);
+ } finally {
+ lock.unlock();
}
}
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- public static void removeVpnOpInstance(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
+ static InstanceIdentifier<LearntVpnVipToPort> buildLearntVpnVipToPortIdentifier(String vpnName,
+ String fixedIp) {
+ return InstanceIdentifier.builder(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class,
+ new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
+ }
+
+ public void removeLearntVpnVipToPort(String vpnName, String fixedIp,
+ @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
+ final InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
+ final ReentrantLock lock = lockFor(vpnName, fixedIp);
+ lock.lock();
try {
- // Clean up VPNInstanceOpDataEntry
- if (writeTxn != null) {
- writeTxn.delete(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName));
+ if (writeOperTxn != null) {
+ writeOperTxn.delete(id);
} else {
- delete(broker, LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(vpnName),
- DEFAULT_CALLBACK);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
}
- } catch (Exception e) {
- LOG.error("removeVpnOpInstance: Exception during cleanup of VPNInstanceOpDataEntry for VPN {}",
- vpnName, e);
+ LOG.debug("removeLearntVpnVipToPort: Deleted LearntVpnVipToPort entry for fixedIp: {}, vpn {}",
+ fixedIp, vpnName);
+ } finally {
+ lock.unlock();
}
}
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- public static void removeVpnInstanceToVpnId(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
+ public static void removeVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp,
+ @Nullable TypedWriteTransaction<Configuration> writeConfigTxn) {
+ final InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
+ final ReentrantLock lock = lockFor(vpnName, fixedIp);
+ lock.lock();
try {
- if (writeTxn != null) {
- writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
- VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
+ if (writeConfigTxn != null) {
+ writeConfigTxn.delete(id);
} else {
- delete(broker, LogicalDatastoreType.CONFIGURATION,
- VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName),
- DEFAULT_CALLBACK);
+ MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, id);
}
- } catch (Exception e) {
- LOG.error("removeVpnInstanceToVpnId: Exception during clean up of VpnInstanceToVpnId for VPN {}",
- vpnName, e);
+ LOG.debug("removeVpnPortFixedIpToPort: Deleted VpnPortipToPort entry for fixedIp: {}, vpn {}",
+ fixedIp, vpnName);
+ } finally {
+ lock.unlock();
}
}
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- public static void removeVpnIdToVpnInstance(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
- try {
- if (writeTxn != null) {
- writeTxn.delete(LogicalDatastoreType.CONFIGURATION, getVpnIdToVpnInstanceIdentifier(vpnId));
- } else {
- delete(broker, LogicalDatastoreType.CONFIGURATION, getVpnIdToVpnInstanceIdentifier(vpnId),
- DEFAULT_CALLBACK);
- }
- } catch (Exception e) {
- LOG.error("removeVpnIdToVpnInstance: Exception during clean up of VpnIdToVpnInstance for VPNID {}",
- vpnId, e);
+ public void createLearntVpnVipToPortEvent(String vpnName, String srcIp, String destIP, String portName,
+ String macAddress, LearntVpnVipToPortEventAction action,
+ TypedWriteTransaction<Operational> writeOperTxn) {
+ String eventId = MicroTimestamp.INSTANCE.get();
+
+ InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
+ LearntVpnVipToPortEventBuilder builder = new LearntVpnVipToPortEventBuilder().withKey(
+ new LearntVpnVipToPortEventKey(eventId)).setVpnName(vpnName).setSrcFixedip(srcIp)
+ .setDestFixedip(destIP).setPortName(portName)
+ .setMacAddress(macAddress.toLowerCase(Locale.getDefault())).setEventAction(action);
+ if (writeOperTxn != null) {
+ writeOperTxn.delete(id);
+ } else {
+ syncWrite(LogicalDatastoreType.OPERATIONAL, id, builder.build());
}
+ LOG.info("createLearntVpnVipToPortEvent: ARP learn event created for fixedIp: {}, vpn {}, interface {},"
+ + " mac {} action {} eventId {}", srcIp, vpnName, portName, macAddress, action, eventId);
}
- // TODO Clean up the exception handling
- @SuppressWarnings("checkstyle:IllegalCatch")
- public static void removeVrfTableForVpn(DataBroker broker, String vpnName, WriteTransaction writeTxn) {
- // Clean up FIB Entries Config DS
- try {
- if (writeTxn != null) {
- writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class,
- new VrfTablesKey(vpnName)).build());
- } else {
- delete(broker, LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class,
- new VrfTablesKey(vpnName)).build(),
- DEFAULT_CALLBACK);
- }
- } catch (Exception e) {
- LOG.error("removeVrfTableForVpn: Exception during clean up of VrfTable from FIB for VPN {}",
- vpnName, e);
+ private static InstanceIdentifier<LearntVpnVipToPortEvent> buildLearntVpnVipToPortEventIdentifier(String eventId) {
+ InstanceIdentifier<LearntVpnVipToPortEvent> id = InstanceIdentifier.builder(LearntVpnVipToPortEventData.class)
+ .child(LearntVpnVipToPortEvent.class, new LearntVpnVipToPortEventKey(eventId)).build();
+ return id;
+ }
+
+ public void removeLearntVpnVipToPortEvent(String eventId,
+ @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
+ InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
+ if (writeOperTxn != null) {
+ writeOperTxn.delete(id);
+ } else {
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
}
+ LOG.info("removeLearntVpnVipToPortEvent: Deleted Event {}", eventId);
+
}
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
- public static void removeL3nexthopForVpnId(DataBroker broker, long vpnId, WriteTransaction writeTxn) {
+ public void removeMipAdjAndLearntIp(String vpnName, String vpnInterface, String prefix) {
+ final ReentrantLock lock = lockFor(vpnName, prefix);
+ lock.lock();
try {
- // Clean up L3NextHop Operational DS
- if (writeTxn != null) {
- writeTxn.delete(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class,
- new VpnNexthopsKey(vpnId)).build());
- } else {
- delete(broker, LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(L3nexthop.class).child(VpnNexthops.class,
- new VpnNexthopsKey(vpnId)).build(),
- DEFAULT_CALLBACK);
+ String ip = VpnUtil.getIpPrefix(prefix);
+ InstanceIdentifier<VpnInterfaceOpDataEntry> vpnInterfaceOpId = VpnUtil
+ .getVpnInterfaceOpDataEntryIdentifier(vpnInterface, vpnName);
+ InstanceIdentifier<AdjacenciesOp> path = vpnInterfaceOpId.augmentation(AdjacenciesOp.class);
+ Optional<AdjacenciesOp> adjacenciesOp = read(LogicalDatastoreType.OPERATIONAL, path);
+ if (adjacenciesOp.isPresent()) {
+ InstanceIdentifier<Adjacency> adjacencyIdentifier = InstanceIdentifier.builder(VpnInterfaces.class)
+ .child(VpnInterface.class, new VpnInterfaceKey(vpnInterface))
+ .augmentation(Adjacencies.class).child(Adjacency.class, new AdjacencyKey(ip)).build();
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, adjacencyIdentifier);
+ LOG.info("removeMipAdjAndLearntIp: Successfully Deleted Adjacency {} from interface {} vpn {}", ip,
+ vpnInterface, vpnName);
}
+ InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, prefix);
+ MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ LOG.info("removeMipAdjAndLearntIp: Delete learned ARP for fixedIp: {}, vpn {} removed from"
+ + "VpnPortipToPort DS", prefix, vpnName);
} catch (Exception e) {
- LOG.error("removeL3nexthopForVpnId: Exception during cleanup of L3NextHop for VPN ID {}", vpnId, e);
+ LOG.error("removeMipAdjAndLearntIp: Exception Deleting learned Ip: {} interface {} vpn {} from "
+ + "LearntVpnPortipToPort DS", prefix, vpnInterface, vpnName, e);
+ } finally {
+ lock.unlock();
}
+ VpnUtil.removeVpnPortFixedIpToPort(dataBroker, vpnName, prefix, null);
}
- public static void scheduleVpnInterfaceForRemoval(DataBroker broker,String interfaceName, BigInteger dpnId,
- String vpnInstanceName, Boolean isScheduledToRemove,
- WriteTransaction writeOperTxn) {
- InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
- VpnUtil.getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnInstanceName);
- VpnInterfaceOpDataEntry interfaceToUpdate =
- new VpnInterfaceOpDataEntryBuilder().setKey(new VpnInterfaceOpDataEntryKey(interfaceName,
- vpnInstanceName)).setName(interfaceName).setDpnId(dpnId).setVpnInstanceName(vpnInstanceName)
- .setScheduledForRemove(isScheduledToRemove).build();
- if (writeOperTxn != null) {
- writeOperTxn.merge(LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate, true);
- } else {
- VpnUtil.syncUpdate(broker, LogicalDatastoreType.OPERATIONAL, interfaceId, interfaceToUpdate);
- }
- }
+ public void removeMipAdjacency(String vpnName, String vpnInterface, String prefix,
+ TypedWriteTransaction<Configuration> writeConfigTxn) {
+ String ip = VpnUtil.getIpPrefix(prefix);
+ LOG.trace("Removing {} adjacency from Old VPN Interface {} ", ip, vpnInterface);
+ InstanceIdentifier<VpnInterface> vpnIfId = VpnUtil.getVpnInterfaceIdentifier(vpnInterface);
+ InstanceIdentifier<Adjacencies> path = vpnIfId.augmentation(Adjacencies.class);
+ //TODO: Remove synchronized?
- protected static void createLearntVpnVipToPort(DataBroker broker, String vpnName, String fixedIp, String
- portName, String macAddress) {
- synchronized ((vpnName + fixedIp).intern()) {
- InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
- LearntVpnVipToPortBuilder builder =
- new LearntVpnVipToPortBuilder().setKey(new LearntVpnVipToPortKey(fixedIp, vpnName)).setVpnName(
- vpnName).setPortFixedip(fixedIp).setPortName(portName)
- .setMacAddress(macAddress.toLowerCase(Locale.getDefault()))
- .setCreationTime(new SimpleDateFormat("MM/dd/yyyy h:mm:ss a").format(new Date()));
- MDSALUtil.syncWrite(broker, LogicalDatastoreType.OPERATIONAL, id, builder.build());
- LOG.debug("createLearntVpnVipToPort: ARP learned for fixedIp: {}, vpn {}, interface {}, mac {},"
- + " added to VpnPortipToPort DS", fixedIp, vpnName, portName, macAddress);
+ Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.OPERATIONAL, path);
+ if (adjacencies.isPresent()) {
+ InstanceIdentifier<Adjacency> adjacencyIdentifier = getAdjacencyIdentifier(vpnInterface, prefix);
+ writeConfigTxn.delete(adjacencyIdentifier);
+ LOG.error("removeMipAdjacency: Successfully Deleted Adjacency {} from interface {} vpn {}", ip,
+ vpnInterface, vpnName);
}
}
- private static InstanceIdentifier<LearntVpnVipToPort> buildLearntVpnVipToPortIdentifier(String vpnName,
- String fixedIp) {
- return InstanceIdentifier.builder(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class,
- new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
- }
-
- protected static void removeLearntVpnVipToPort(DataBroker broker, String vpnName, String fixedIp) {
- synchronized ((vpnName + fixedIp).intern()) {
- InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
- MDSALUtil.syncDelete(broker, LogicalDatastoreType.OPERATIONAL, id);
- LOG.debug("removeLearntVpnVipToPort: Delete learned ARP for fixedIp: {}, vpn {} removed from"
- + " VpnPortipToPort DS", fixedIp, vpnName);
+ public void removeMipAdjacency(String vpnInterface, String ipAddress) {
+ String prefix = VpnUtil.getIpPrefix(ipAddress);
+ InstanceIdentifier<Adjacency> adjacencyIdentifier = getAdjacencyIdentifier(vpnInterface, prefix);
+ try {
+ SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ adjacencyIdentifier);
+ } catch (TransactionCommitFailedException e) {
+ if (e.getCause() instanceof ModifiedNodeDoesNotExistException) {
+ LOG.debug("vpnInterface {} is already deleted. prefix={}", vpnInterface, prefix);
+ } else {
+ LOG.error("Failed to delete adjacency for vpnInterface {}, prefix {}", vpnInterface, prefix, e);
+ }
}
}
new VpnPortipToPortKey(fixedIp, vpnName)).build();
}
- public static VpnPortipToPort getNeutronPortFromVpnPortFixedIp(DataBroker broker, String vpnName, String fixedIp) {
+ @Nullable
+ public VpnPortipToPort getNeutronPortFromVpnPortFixedIp(String vpnName, String fixedIp) {
InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
- Optional<VpnPortipToPort> vpnPortipToPortData = read(broker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnPortipToPort> vpnPortipToPortData = read(LogicalDatastoreType.CONFIGURATION, id);
if (vpnPortipToPortData.isPresent()) {
return vpnPortipToPortData.get();
}
return null;
}
- static LearntVpnVipToPort getLearntVpnVipToPort(DataBroker broker, String vpnName, String fixedIp) {
+ @Nullable
+ public static VpnPortipToPort getNeutronPortFromVpnPortFixedIp(TypedReadTransaction<Configuration> confTx,
+ String vpnName, String fixedIp) {
+ InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
+ try {
+ return confTx.read(id).get().orNull();
+ } catch (InterruptedException | ExecutionException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ @Nullable
+ public LearntVpnVipToPort getLearntVpnVipToPort(String vpnName, String fixedIp) {
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
- Optional<LearntVpnVipToPort> learntVpnVipToPort = read(broker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<LearntVpnVipToPort> learntVpnVipToPort = read(LogicalDatastoreType.OPERATIONAL, id);
if (learntVpnVipToPort.isPresent()) {
return learntVpnVipToPort.get();
}
return null;
}
- @Nonnull
- public static List<BigInteger> getDpnsOnVpn(DataBroker dataBroker, String vpnInstanceName) {
- List<BigInteger> result = new ArrayList<>();
- String rd = getVpnRd(dataBroker, vpnInstanceName);
+ @NonNull
+ List<Uint64> getDpnsOnVpn(String vpnInstanceName) {
+ List<Uint64> result = new ArrayList<>();
+ String rd = getVpnRd(vpnInstanceName);
if (rd == null) {
LOG.debug("getDpnsOnVpn: Could not find Route-Distinguisher for VpnName={}", vpnInstanceName);
return result;
}
-
- VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(dataBroker, rd);
+ VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
if (vpnInstanceOpData == null) {
LOG.debug("getDpnsOnVpn: Could not find OpState for VpnName={}", vpnInstanceName);
return result;
}
-
List<VpnToDpnList> vpnToDpnList = vpnInstanceOpData.getVpnToDpnList();
if (vpnToDpnList == null) {
LOG.debug("getDpnsOnVpn: Could not find DPN footprint for VpnName={}", vpnInstanceName);
return result;
}
- static String getAssociatedExternalNetwork(DataBroker dataBroker, String routerId) {
- InstanceIdentifier<Routers> id = buildRouterIdentifier(routerId);
- Optional<Routers> routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
- if (routerData.isPresent()) {
- Uuid networkId = routerData.get().getNetworkId();
- if (networkId != null) {
- return networkId.getValue();
+ @Nullable
+ String getAssociatedExternalRouter(String extIp) {
+ InstanceIdentifier<ExtRouters> extRouterInstanceIndentifier =
+ InstanceIdentifier.builder(ExtRouters.class).build();
+ Optional<ExtRouters> extRouterData = read(LogicalDatastoreType.CONFIGURATION, extRouterInstanceIndentifier);
+ if (!extRouterData.isPresent()) {
+ return null;
+ }
+
+ // We need to find the router associated with the src ip of this packet.
+ // This case is either SNAT, in which case the src ip is the same as the
+ // router's external ip, or FIP in which case the src ip is in the router's
+ // external leg's subnet. We first check the SNAT case because it is much
+ // cheaper to do so because it does not require (potentially, there is a
+ // cache) an datastore read of the neutron subnet for each external IP.
+
+ String routerName = null;
+
+ for (Routers routerData : extRouterData.get().nonnullRouters()) {
+ List<ExternalIps> externalIps = routerData.nonnullExternalIps();
+ for (ExternalIps externalIp : externalIps) {
+ if (Objects.equals(externalIp.getIpAddress(), extIp)) {
+ routerName = routerData.getRouterName();
+ break;
+ }
}
}
- return null;
+
+ if (routerName != null) {
+ return routerName;
+ }
+
+ for (Routers routerData : extRouterData.get().nonnullRouters()) {
+ List<ExternalIps> externalIps = routerData.nonnullExternalIps();
+ for (ExternalIps externalIp : externalIps) {
+ Subnet neutronSubnet = neutronVpnService.getNeutronSubnet(externalIp.getSubnetId());
+ if (neutronSubnet == null) {
+ LOG.warn("Failed to retrieve subnet {} referenced by router {}",
+ externalIp.getSubnetId(), routerData);
+ continue;
+ }
+ if (NWUtil.isIpAddressInRange(IpAddressBuilder.getDefaultInstance(extIp), neutronSubnet.getCidr())) {
+ routerName = routerData.getRouterName();
+ break;
+ }
+ }
+ }
+
+ return routerName;
}
- public static String getAssociatedExternalRouter(DataBroker dataBroker, String extIp) {
+ @Nullable
+ public String getAssociatedExternalSubnet(String extIp) {
InstanceIdentifier<ExtRouters> extRouterInstanceIndentifier =
InstanceIdentifier.builder(ExtRouters.class).build();
- Optional<ExtRouters> extRouterData = read(dataBroker, LogicalDatastoreType.CONFIGURATION,
- extRouterInstanceIndentifier);
- if (extRouterData.isPresent()) {
- for (Routers routerData : extRouterData.get().getRouters()) {
- List<ExternalIps> externalIps = routerData.getExternalIps();
+ Optional<ExtRouters> extRouterData = read(LogicalDatastoreType.CONFIGURATION, extRouterInstanceIndentifier);
+ if (!extRouterData.isPresent() || extRouterData.get().getRouters() == null) {
+ return null;
+ }
+ for (Routers routerData : extRouterData.get().getRouters()) {
+ List<ExternalIps> externalIps = routerData.getExternalIps();
+ if (externalIps != null) {
for (ExternalIps externalIp : externalIps) {
- if (externalIp.getIpAddress().equals(extIp)) {
- return routerData.getRouterName();
+ Subnet neutronSubnet = neutronVpnService.getNeutronSubnet(externalIp.getSubnetId());
+ if (neutronSubnet == null) {
+ LOG.warn("Failed to retrieve subnet {} referenced by router {}",
+ externalIp.getSubnetId(), routerData);
+ continue;
+ }
+ if (NWUtil.isIpAddressInRange(IpAddressBuilder.getDefaultInstance(extIp),
+ neutronSubnet.getCidr())) {
+ return neutronSubnet.getUuid().getValue();
}
}
}
return InstanceIdentifier.builder(ExtRouters.class).child(Routers.class, new RoutersKey(routerId)).build();
}
- static Networks getExternalNetwork(DataBroker dataBroker, Uuid networkId) {
+ @Nullable
+ Networks getExternalNetwork(Uuid networkId) {
InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
.child(Networks.class, new NetworksKey(networkId)).build();
- Optional<Networks> optionalNets = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, netsIdentifier);
+ Optional<Networks> optionalNets = read(LogicalDatastoreType.CONFIGURATION, netsIdentifier);
return optionalNets.isPresent() ? optionalNets.get() : null;
}
- static Uuid getExternalNetworkVpnId(DataBroker dataBroker, Uuid networkId) {
- Networks extNetwork = getExternalNetwork(dataBroker, networkId);
+ @Nullable
+ Uuid getExternalNetworkVpnId(Uuid networkId) {
+ Networks extNetwork = getExternalNetwork(networkId);
return extNetwork != null ? extNetwork.getVpnid() : null;
}
- static List<Uuid> getExternalNetworkRouterIds(DataBroker dataBroker, Uuid networkId) {
- Networks extNetwork = getExternalNetwork(dataBroker, networkId);
- return extNetwork != null ? extNetwork.getRouterIds() : Collections.emptyList();
+ @NonNull
+ public List<Uuid> getExternalNetworkRouterIds(Uuid networkId) {
+ Networks extNetwork = getExternalNetwork(networkId);
+ return extNetwork != null && extNetwork.getRouterIds() != null ? extNetwork.getRouterIds() : emptyList();
}
- static Routers getExternalRouter(DataBroker dataBroker, String routerId) {
- InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class)
- .child(Routers.class, new RoutersKey(routerId)).build();
- Optional<Routers> routerData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ @Nullable
+ Routers getExternalRouter(String routerId) {
+ InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class).child(Routers.class,
+ new RoutersKey(routerId)).build();
+ Optional<Routers> routerData = read(LogicalDatastoreType.CONFIGURATION, id);
return routerData.isPresent() ? routerData.get() : null;
}
- static List<String> getAllSubnetGatewayMacAddressesforVpn(DataBroker broker, String vpnName) {
- List<String> macAddresses = new ArrayList<>();
- Optional<Subnetmaps> subnetMapsData =
- read(broker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
- if (subnetMapsData.isPresent()) {
- List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
- if (subnetMapList != null && !subnetMapList.isEmpty()) {
- for (Subnetmap subnet : subnetMapList) {
- if (subnet.getVpnId() != null && subnet.getVpnId().equals(Uuid.getDefaultInstance(vpnName))) {
- String routerIntfMacAddress = subnet.getRouterIntfMacAddress();
- if (routerIntfMacAddress != null && !routerIntfMacAddress.isEmpty()) {
- macAddresses.add(subnet.getRouterIntfMacAddress());
- }
- }
- }
- }
- }
- return macAddresses;
+ @Nullable
+ Routers getExternalRouter(TypedReadTransaction<Configuration> tx, String routerId)
+ throws ExecutionException, InterruptedException {
+ InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class).child(Routers.class,
+ new RoutersKey(routerId)).build();
+ return tx.read(id).get().orNull();
}
static InstanceIdentifier<Subnetmaps> buildSubnetMapsWildCardPath() {
return InstanceIdentifier.create(Subnetmaps.class);
}
- public static FlowEntity buildL3vpnGatewayFlow(BigInteger dpId, String gwMacAddress, long vpnId,
- long subnetVpnId) {
+ FlowEntity buildL3vpnGatewayFlow(Uint64 dpId, String gwMacAddress, Uint32 vpnId,
+ Uint32 subnetVpnId) {
List<MatchInfo> mkMatches = new ArrayList<>();
- mkMatches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnId), MetaDataUtil.METADATA_MASK_VRFID));
+ Subnetmap smap = null;
+ mkMatches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnId.longValue()),
+ MetaDataUtil.METADATA_MASK_VRFID));
mkMatches.add(new MatchEthernetDestination(new MacAddress(gwMacAddress)));
List<InstructionInfo> mkInstructions = new ArrayList<>();
mkInstructions.add(new InstructionGotoTable(NwConstants.L3_FIB_TABLE));
- if (subnetVpnId != VpnConstants.INVALID_ID) {
- BigInteger subnetIdMetaData = MetaDataUtil.getVpnIdMetadata(subnetVpnId);
+ if (!VpnConstants.INVALID_ID.equals(subnetVpnId)) {
+ String vpnName = getVpnName(subnetVpnId);
+ if (vpnName != null) {
+ smap = getSubnetmapFromItsUuid(Uuid.getDefaultInstance(vpnName));
+ if (smap != null && smap.getSubnetIp() != null) {
+ IpVersionChoice ipVersionChoice = getIpVersionFromString(smap.getSubnetIp());
+ if (ipVersionChoice == IpVersionChoice.IPV4) {
+ mkMatches.add(MatchEthernetType.IPV4);
+ } else {
+ mkMatches.add(MatchEthernetType.IPV6);
+ }
+ }
+ }
+ Uint64 subnetIdMetaData = MetaDataUtil.getVpnIdMetadata(subnetVpnId.longValue());
mkInstructions.add(new InstructionWriteMetadata(subnetIdMetaData, MetaDataUtil.METADATA_MASK_VRFID));
}
-
- String flowId = getL3VpnGatewayFlowRef(NwConstants.L3_GW_MAC_TABLE, dpId, vpnId, gwMacAddress);
-
+ String flowId = getL3VpnGatewayFlowRef(NwConstants.L3_GW_MAC_TABLE, dpId, vpnId, gwMacAddress, subnetVpnId);
return MDSALUtil.buildFlowEntity(dpId, NwConstants.L3_GW_MAC_TABLE,
- flowId, 20, flowId, 0, 0, NwConstants.COOKIE_L3_GW_MAC_TABLE, mkMatches, mkInstructions);
+ flowId, 20, flowId, 0, 0, NwConstants.COOKIE_L3_GW_MAC_TABLE,
+ mkMatches, mkInstructions);
}
- private static String getL3VpnGatewayFlowRef(short l3GwMacTable, BigInteger dpId, long vpnId, String gwMacAddress) {
+ static String getL3VpnGatewayFlowRef(short l3GwMacTable, Uint64 dpId, Uint32 vpnId, String gwMacAddress,
+ Uint32 subnetVpnId) {
return gwMacAddress + NwConstants.FLOWID_SEPARATOR + vpnId + NwConstants.FLOWID_SEPARATOR + dpId
- + NwConstants.FLOWID_SEPARATOR + l3GwMacTable;
+ + NwConstants.FLOWID_SEPARATOR + l3GwMacTable + NwConstants.FLOWID_SEPARATOR + subnetVpnId;
}
- public static void lockSubnet(LockManagerService lockManager, String subnetId) {
+ void lockSubnet(String subnetId) {
+ // We set the total wait time for lock to be obtained at 9 seconds since GC pauses can be upto 8 seconds
+ //in scale setups.
TryLockInput input =
- new TryLockInputBuilder().setLockName(subnetId).setTime(3000L).setTimeUnit(TimeUnits.Milliseconds).build();
- Future<RpcResult<Void>> result = lockManager.tryLock(input);
+ new TryLockInputBuilder().setLockName(subnetId).setTime(9000L).setTimeUnit(TimeUnits.Milliseconds).build();
+ Future<RpcResult<TryLockOutput>> result = lockManager.tryLock(input);
try {
if (result != null && result.get().isSuccessful()) {
LOG.debug("lockSubnet: Acquired lock for {}", subnetId);
// We store the cause, which is what we really care about
@SuppressWarnings("checkstyle:AvoidHidingCauseException")
- public static void unlockSubnet(LockManagerService lockManager, String subnetId) {
+ public void unlockSubnet(String subnetId) {
UnlockInput input = new UnlockInputBuilder().setLockName(subnetId).build();
- Future<RpcResult<Void>> result = lockManager.unlock(input);
+ Future<RpcResult<UnlockOutput>> result = lockManager.unlock(input);
try {
if (result != null && result.get().isSuccessful()) {
LOG.debug("unlockSubnet: Unlocked {}", subnetId);
}
}
- static Optional<IpAddress> getGatewayIpAddressFromInterface(String srcInterface,
- INeutronVpnManager neutronVpnService) {
+ public Optional<IpAddress> getGatewayIpAddressFromInterface(MacEntry macEntry) {
Optional<IpAddress> gatewayIp = Optional.absent();
+ String srcInterface = macEntry.getInterfaceName();
+ InetAddress hiddenIp = macEntry.getIpAddress();
if (neutronVpnService != null) {
//TODO(Gobinath): Need to fix this as assuming port will belong to only one Subnet would be incorrect"
Port port = neutronVpnService.getNeutronPort(srcInterface);
- if (port != null && port.getFixedIps() != null && port.getFixedIps().get(0) != null
- && port.getFixedIps().get(0).getSubnetId() != null) {
- gatewayIp = Optional.of(
- neutronVpnService.getNeutronSubnet(port.getFixedIps().get(0).getSubnetId()).getGatewayIp());
+ if (port != null && port.getFixedIps() != null) {
+ for (FixedIps portIp : port.getFixedIps()) {
+ if (doesInterfaceAndHiddenIpAddressTypeMatch(hiddenIp, portIp)) {
+ gatewayIp =
+ Optional.of(neutronVpnService.getNeutronSubnet(portIp.getSubnetId()).getGatewayIp());
+ break;
+ }
+ }
}
} else {
LOG.error("getGatewayIpAddressFromInterface: neutron vpn service is not configured."
return gatewayIp;
}
- static Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp,
- DataBroker dataBroker) {
+ private boolean doesInterfaceAndHiddenIpAddressTypeMatch(InetAddress hiddenIp, FixedIps portIp) {
+ return hiddenIp instanceof Inet4Address && portIp.getIpAddress().getIpv4Address() != null
+ || hiddenIp instanceof Inet6Address && portIp.getIpAddress().getIpv6Address() != null;
+ }
+
+ public Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp) {
Optional<String> gatewayMac = Optional.absent();
- long vpnId = getVpnId(dataBroker, macEntry.getVpnName());
+ Uint32 vpnId = getVpnId(macEntry.getVpnName());
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
.instance.VpnIds>
vpnIdsInstanceIdentifier = VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId);
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
- vpnIdsOptional
- = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
+ vpnIdsOptional = read(LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
if (!vpnIdsOptional.isPresent()) {
LOG.error("getGWMacAddressFromInterface: VPN {} not configured", vpnId);
return gatewayMac;
}
- VpnPortipToPort vpnTargetIpToPort = VpnUtil.getNeutronPortFromVpnPortFixedIp(dataBroker,
- macEntry.getVpnName(), gatewayIp.getIpv4Address().getValue());
+ VpnPortipToPort vpnTargetIpToPort =
+ getNeutronPortFromVpnPortFixedIp(macEntry.getVpnName(), gatewayIp.stringValue());
if (vpnTargetIpToPort != null && vpnTargetIpToPort.isSubnetIp()) {
gatewayMac = Optional.of(vpnTargetIpToPort.getMacAddress());
} else {
- org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds vpnIds =
- vpnIdsOptional.get();
+ org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
+ .vpn.id.to.vpn.instance.VpnIds vpnIds = vpnIdsOptional.get();
if (vpnIds.isExternalVpn()) {
gatewayMac = InterfaceUtils.getMacAddressForInterface(dataBroker, macEntry.getInterfaceName());
}
return gatewayMac;
}
- public static void setupGwMacIfExternalVpn(DataBroker dataBroker, IMdsalApiManager mdsalManager, BigInteger dpnId,
- String interfaceName, long vpnId, WriteTransaction writeInvTxn, int addOrRemove, String gwMac) {
+ void setupGwMacIfExternalVpn(Uint64 dpnId, String interfaceName, Uint32 vpnId,
+ TypedReadWriteTransaction<Configuration> writeInvTxn, int addOrRemove, String gwMac)
+ throws ExecutionException, InterruptedException {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
.VpnIds> vpnIdsInstanceIdentifier = getVpnIdToVpnInstanceIdentifier(vpnId);
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
- .VpnIds> vpnIdsOptional = read(
- dataBroker, LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
+ .VpnIds> vpnIdsOptional = writeInvTxn.read(vpnIdsInstanceIdentifier).get();
if (vpnIdsOptional.isPresent() && vpnIdsOptional.get().isExternalVpn()) {
if (gwMac == null) {
LOG.error("setupGwMacIfExternalVpn: Failed to get gwMacAddress for interface {} on dpn {} vpn {}",
interfaceName, dpnId.toString(), vpnIdsOptional.get().getVpnInstanceName());
return;
}
- FlowEntity flowEntity = VpnUtil.buildL3vpnGatewayFlow(dpnId, gwMac, vpnId, VpnConstants.INVALID_ID);
+ FlowEntity flowEntity = buildL3vpnGatewayFlow(dpnId, gwMac, vpnId,VpnConstants.INVALID_ID);
if (addOrRemove == NwConstants.ADD_FLOW) {
- mdsalManager.addFlowToTx(flowEntity, writeInvTxn);
+ mdsalManager.addFlow(writeInvTxn, flowEntity);
} else if (addOrRemove == NwConstants.DEL_FLOW) {
- mdsalManager.removeFlowToTx(flowEntity, writeInvTxn);
- }
- }
- }
-
- public static Optional<VpnPortipToPort> getRouterInterfaceForVpnInterface(DataBroker dataBroker,
- String vpnName,
- Uuid subnetUuid) {
- Optional<VpnPortipToPort> gwPortOptional = Optional.absent();
- if (subnetUuid != null) {
- final Optional<String> gatewayIp = getVpnSubnetGatewayIp(dataBroker, subnetUuid);
- if (gatewayIp.isPresent()) {
- String gwIp = gatewayIp.get();
- gwPortOptional = Optional.fromNullable(getNeutronPortFromVpnPortFixedIp(dataBroker, vpnName, gwIp));
+ mdsalManager.removeFlow(writeInvTxn, flowEntity);
}
}
- return gwPortOptional;
}
- public static Optional<String> getVpnSubnetGatewayIp(DataBroker dataBroker, final Uuid subnetUuid) {
+ public Optional<String> getVpnSubnetGatewayIp(final Uuid subnetUuid) {
Optional<String> gwIpAddress = Optional.absent();
final SubnetKey subnetkey = new SubnetKey(subnetUuid);
final InstanceIdentifier<Subnet> subnetidentifier = InstanceIdentifier.create(Neutron.class)
.child(Subnets.class)
.child(Subnet.class, subnetkey);
- final Optional<Subnet> subnet = read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetidentifier);
+ final Optional<Subnet> subnet = read(LogicalDatastoreType.CONFIGURATION, subnetidentifier);
if (subnet.isPresent()) {
Class<? extends IpVersionBase> ipVersionBase = subnet.get().getIpVersion();
- if (ipVersionBase.equals(IpVersionV4.class)) {
- LOG.trace("getVpnSubnetGatewayIp: Obtained subnet {} for vpn interface",
- subnet.get().getUuid().getValue());
- IpAddress gwIp = subnet.get().getGatewayIp();
- if (gwIp != null && gwIp.getIpv4Address() != null) {
- gwIpAddress = Optional.of(gwIp.getIpv4Address().getValue());
+ if (IpVersionV4.class.equals(ipVersionBase)) {
+ Subnetmap subnetmap = getSubnetmapFromItsUuid(subnetUuid);
+ if (subnetmap != null && subnetmap.getRouterInterfaceFixedIp() != null) {
+ LOG.trace("getVpnSubnetGatewayIp: Obtained subnetMap {} for vpn interface",
+ subnetmap.getId().getValue());
+ gwIpAddress = Optional.of(subnetmap.getRouterInterfaceFixedIp());
+ } else {
+ //For direct L3VPN to network association (no router) continue to use subnet-gateway IP
+ IpAddress gwIp = subnet.get().getGatewayIp();
+ if (gwIp != null && gwIp.getIpv4Address() != null) {
+ gwIpAddress = Optional.of(gwIp.getIpv4Address().getValue());
+ }
}
+ LOG.trace("getVpnSubnetGatewayIp: Obtained subnet-gw ip {} for vpn interface",
+ gwIpAddress.get());
}
}
return gwIpAddress;
}
- public static RouterToNaptSwitch getRouterToNaptSwitch(DataBroker dataBroker, String routerName) {
+ @Nullable
+ RouterToNaptSwitch getRouterToNaptSwitch(String routerName) {
InstanceIdentifier<RouterToNaptSwitch> id = InstanceIdentifier.builder(NaptSwitches.class)
.child(RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerName)).build();
- Optional<RouterToNaptSwitch> routerToNaptSwitchData = read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<RouterToNaptSwitch> routerToNaptSwitchData = read(LogicalDatastoreType.CONFIGURATION, id);
return routerToNaptSwitchData.isPresent() ? routerToNaptSwitchData.get() : null;
}
}
- public static BigInteger getPrimarySwitchForRouter(DataBroker dataBroker, String routerName) {
- RouterToNaptSwitch routerToNaptSwitch = getRouterToNaptSwitch(dataBroker, routerName);
+ @Nullable
+ Uint64 getPrimarySwitchForRouter(String routerName) {
+ RouterToNaptSwitch routerToNaptSwitch = getRouterToNaptSwitch(routerName);
return routerToNaptSwitch != null ? routerToNaptSwitch.getPrimarySwitchId() : null;
}
- static boolean isL3VpnOverVxLan(Long l3Vni) {
- return l3Vni != null && l3Vni != 0;
- }
-
- static boolean isEvpnOverVxLan(Long l2Vni) { //To be used by RT2
- return l2Vni != null && l2Vni != 0;
+ static boolean isL3VpnOverVxLan(Uint32 l3Vni) {
+ return l3Vni != null && l3Vni.longValue() != 0;
}
/**
* If rd list is empty, primary rd will be vpn instance name
* Use this function only during create operation cycles. For other operations, use getVpnRd() method.
*
- * @param dataBroker dataBroker service reference
* @param vpnName Name of the VPN
* @return the primary rd of the VPN
*/
- public static String getPrimaryRd(DataBroker dataBroker, String vpnName) {
+ public String getPrimaryRd(String vpnName) {
// Retrieves the VPN Route Distinguisher by its Vpn instance name
- String rd = getVpnRd(dataBroker, vpnName);
+ String rd = getVpnRd(vpnName);
if (rd != null) {
return rd;
}
InstanceIdentifier<VpnInstance> id = getVpnInstanceIdentifier(vpnName);
- Optional<VpnInstance> vpnInstance = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, id);
+ Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
if (vpnInstance.isPresent()) {
return getPrimaryRd(vpnInstance.get());
}
* @param vpnInstance Config Vpn Instance Object
* @return the primary rd of the VPN
*/
- public static String getPrimaryRd(VpnInstance vpnInstance) {
+ static String getPrimaryRd(VpnInstance vpnInstance) {
List<String> rds = null;
if (vpnInstance != null) {
rds = getListOfRdsFromVpnInstance(vpnInstance);
return rds == null || rds.isEmpty() ? vpnInstance.getVpnInstanceName() : rds.get(0);
}
- public static boolean isBgpVpn(String vpnName, String primaryRd) {
+ static boolean isBgpVpn(String vpnName, String primaryRd) {
return !vpnName.equals(primaryRd);
}
- static java.util.Optional<String> allocateRdForExtraRouteAndUpdateUsedRdsMap(
- DataBroker dataBroker, long vpnId, @Nullable Long parentVpnId, String prefix, String vpnName,
- String nextHop, BigInteger dpnId) {
+ java.util.Optional<String> allocateRdForExtraRouteAndUpdateUsedRdsMap(Uint32 vpnId, @Nullable Uint32 parentVpnId,
+ String prefix, String vpnName,
+ String nextHop, Uint64 dpnId) {
//Check if rd is already allocated for this extraroute behind the same VM. If yes, reuse it.
//This is particularly useful during reboot scenarios.
java.util.Optional<String> allocatedRd = VpnExtraRouteHelper
// In case of VPN importing the routes, the interface is not present in the VPN
// and has to be fetched from the VPN from which it imports
Optional<Prefixes> prefixToInterface =
- getPrefixToInterface(dataBroker, parentVpnId != null ? parentVpnId : vpnId, nextHopIp);
+ getPrefixToInterface(parentVpnId != null ? parentVpnId : vpnId, nextHopIp);
if (prefixToInterface.isPresent() && dpnId.equals(prefixToInterface.get().getDpnId())) {
- syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
+ syncUpdate(LogicalDatastoreType.CONFIGURATION,
VpnExtraRouteHelper.getUsedRdsIdentifier(vpnId, prefix, nextHop),
getRdsBuilder(nextHop, usedRd).build());
return java.util.Optional.of(usedRd);
}
}
}
- List<String> availableRds = getVpnRdsFromVpnInstanceConfig(dataBroker, vpnName);
+ List<String> availableRds = getVpnRdsFromVpnInstanceConfig(vpnName);
String rd;
if (availableRds.isEmpty()) {
rd = dpnId.toString();
} else {
LOG.trace("Removing used rds {} from available rds {} vpnid {} . prefix is {} , vpname- {}, dpnId- {}",
usedRds, availableRds, vpnId, prefix, vpnName, dpnId);
- availableRds.removeAll(usedRds);
+ if (!usedRds.isEmpty()) {
+ availableRds.removeAll(usedRds);
+ }
if (availableRds.isEmpty()) {
LOG.error("No rd available from VpnInstance to allocate for prefix {}", prefix);
return java.util.Optional.empty();
// If rd is not allocated for this prefix or if extra route is behind different OVS, select a new rd.
rd = availableRds.get(0);
}
- syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION,
- VpnExtraRouteHelper.getUsedRdsIdentifier(vpnId, prefix, nextHop),
- getRdsBuilder(nextHop, rd).build());
+ syncUpdate(LogicalDatastoreType.CONFIGURATION,
+ VpnExtraRouteHelper.getUsedRdsIdentifier(vpnId, prefix, nextHop), getRdsBuilder(nextHop, rd).build());
return java.util.Optional.ofNullable(rd);
}
.augmentation(Adjacencies.class).child(Adjacency.class, new AdjacencyKey(ipAddress)).build();
}
+ static InstanceIdentifier<Adjacency> getVpnInterfaceOpDataEntryAdjacencyIdentifier(String intfName,
+ String vpnName,
+ String ipAddress) {
+ LOG.debug("getVpnInterfaceOpDataEntryAdjacencyIdentifier intfName {}, vpnName {}, ipAddress {}",
+ intfName, vpnName, ipAddress);
+ return InstanceIdentifier.builder(VpnInterfaceOpData.class)
+ .child(VpnInterfaceOpDataEntry.class, new VpnInterfaceOpDataEntryKey(intfName, vpnName))
+ .augmentation(AdjacenciesOp.class).child(Adjacency.class, new AdjacencyKey(ipAddress)).build();
+ }
+
public static List<String> getIpsListFromExternalIps(List<ExternalIps> externalIps) {
if (externalIps == null) {
- return Collections.emptyList();
+ return emptyList();
}
return externalIps.stream().map(ExternalIps::getIpAddress).collect(Collectors.toList());
}
- static void bindService(final String vpnInstanceName, final String interfaceName, DataBroker dataBroker,
- boolean isTunnelInterface, JobCoordinator jobCoordinator) {
+ void bindService(final String vpnInstanceName, final String interfaceName, boolean isTunnelInterface) {
jobCoordinator.enqueueJob(interfaceName,
- () -> {
- WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
- BoundServices serviceInfo = isTunnelInterface
- ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
- : getBoundServicesForVpnInterface(dataBroker, vpnInstanceName, interfaceName);
- writeTxn.put(LogicalDatastoreType.CONFIGURATION, InterfaceUtils.buildServiceId(interfaceName,
- ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME, NwConstants.L3VPN_SERVICE_INDEX)),
- serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
- return Collections.singletonList(writeTxn.submit());
- }, SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
- }
-
- static BoundServices getBoundServicesForVpnInterface(DataBroker broker, String vpnName, String interfaceName) {
+ () -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(
+ Datastore.CONFIGURATION, tx -> {
+ BoundServices serviceInfo = isTunnelInterface
+ ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
+ : getBoundServicesForVpnInterface(vpnInstanceName, interfaceName);
+ tx.put(InterfaceUtils.buildServiceId(interfaceName,
+ ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
+ NwConstants.L3VPN_SERVICE_INDEX)),
+ serviceInfo, WriteTransaction.CREATE_MISSING_PARENTS);
+ })), SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
+ }
+
+ BoundServices getBoundServicesForVpnInterface(String vpnName, String interfaceName) {
List<Instruction> instructions = new ArrayList<>();
int instructionKey = 0;
- final long vpnId = VpnUtil.getVpnId(broker, vpnName);
+ final Uint32 vpnId = getVpnId(vpnName);
List<Action> actions = Collections.singletonList(
- new ActionRegLoad(0, VpnConstants.VPN_REG_ID, 0, VpnConstants.VPN_ID_LENGTH, vpnId).buildAction());
+ new ActionRegLoad(0, VpnConstants.VPN_REG_ID, 0, VpnConstants.VPN_ID_LENGTH, vpnId.longValue())
+ .buildAction());
instructions.add(MDSALUtil.buildApplyActionsInstruction(actions, ++instructionKey));
instructions.add(
- MDSALUtil.buildAndGetWriteMetadaInstruction(MetaDataUtil.getVpnIdMetadata(vpnId),
+ MDSALUtil.buildAndGetWriteMetadaInstruction(MetaDataUtil.getVpnIdMetadata(vpnId.longValue()),
MetaDataUtil.METADATA_MASK_VRFID, ++instructionKey));
instructions.add(MDSALUtil.buildAndGetGotoTableInstruction(NwConstants.L3_GW_MAC_TABLE,
++instructionKey));
return serviceInfo;
}
- static void unbindService(DataBroker dataBroker, final String vpnInterfaceName, boolean isInterfaceStateDown,
- JobCoordinator jobCoordinator) {
+ void unbindService(final String vpnInterfaceName, boolean isInterfaceStateDown) {
if (!isInterfaceStateDown) {
jobCoordinator.enqueueJob(vpnInterfaceName,
- () -> {
- WriteTransaction writeTxn = dataBroker.newWriteOnlyTransaction();
- writeTxn.delete(LogicalDatastoreType.CONFIGURATION,
- InterfaceUtils.buildServiceId(vpnInterfaceName,
- ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
- NwConstants.L3VPN_SERVICE_INDEX)));
-
- List<ListenableFuture<Void>> futures = new ArrayList<>();
- futures.add(writeTxn.submit());
- return futures;
- }, SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
+ () -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ Datastore.CONFIGURATION, tx ->
+ tx.delete(InterfaceUtils.buildServiceId(vpnInterfaceName,
+ ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
+ NwConstants.L3VPN_SERVICE_INDEX))))),
+ SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
}
}
- static FlowEntity buildFlowEntity(BigInteger dpnId, short tableId, String flowId) {
- return new FlowEntityBuilder()
- .setDpnId(dpnId)
- .setTableId(tableId)
- .setFlowId(flowId)
- .build();
+ static FlowEntity buildFlowEntity(Uint64 dpnId, short tableId, String flowId) {
+ return new FlowEntityBuilder().setDpnId(dpnId).setTableId(tableId).setFlowId(flowId).build();
}
static VrfEntryBase.EncapType getEncapType(boolean isVxLan) {
return isVxLan ? VrfEntryBase.EncapType.Vxlan : VrfEntryBase.EncapType.Mplsgre;
}
- static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
- .Subnets getExternalSubnet(DataBroker dataBroker, Uuid subnetId) {
+ org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.@Nullable Subnets
+ getExternalSubnet(Uuid subnetId) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
.Subnets> subnetsIdentifier = InstanceIdentifier.builder(ExternalSubnets.class)
.child(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
.Subnets.class, new SubnetsKey(subnetId)).build();
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets>
- optionalSubnets = VpnUtil.read(dataBroker, LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
+ optionalSubnets = read(LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
return optionalSubnets.isPresent() ? optionalSubnets.get() : null;
}
- static Uuid getSubnetFromExternalRouterByIp(DataBroker dataBroker, Uuid routerId, String ip) {
- Routers externalRouter = VpnUtil.getExternalRouter(dataBroker, routerId.getValue());
+ @Nullable
+ public Uuid getSubnetFromExternalRouterByIp(Uuid routerId, String ip) {
+ Routers externalRouter = getExternalRouter(routerId.getValue());
if (externalRouter != null && externalRouter.getExternalIps() != null) {
for (ExternalIps externalIp : externalRouter.getExternalIps()) {
- if (externalIp.getIpAddress().equals(ip)) {
+ if (Objects.equals(externalIp.getIpAddress(), ip)) {
return externalIp.getSubnetId();
}
}
}
static Boolean getIsExternal(Network network) {
- return network.getAugmentation(NetworkL3Extension.class) != null
- && network.getAugmentation(NetworkL3Extension.class).isExternal();
+ return network.augmentation(NetworkL3Extension.class) != null
+ && network.augmentation(NetworkL3Extension.class).isExternal();
}
@SuppressWarnings("checkstyle:linelength")
- static Network getNeutronNetwork(DataBroker broker, Uuid networkId) {
- Network network = null;
+ @Nullable
+ Network getNeutronNetwork(Uuid networkId) {
LOG.debug("getNeutronNetwork for {}", networkId.getValue());
InstanceIdentifier<Network> inst = InstanceIdentifier.create(Neutron.class).child(
org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks.class).child(
Network.class, new NetworkKey(networkId));
- Optional<Network> net = read(broker, LogicalDatastoreType.CONFIGURATION, inst);
- if (net.isPresent()) {
- network = net.get();
- }
- return network;
+ return read(LogicalDatastoreType.CONFIGURATION, inst).orNull();
}
- public static boolean isEligibleForBgp(String rd, String vpnName, BigInteger dpnId, String networkName) {
+ public static boolean isEligibleForBgp(@Nullable String rd, @Nullable String vpnName, @Nullable Uint64 dpnId,
+ @Nullable String networkName) {
if (rd != null) {
- if (vpnName != null && rd.equals(vpnName)) {
+ if (rd.equals(vpnName)) {
return false;
}
if (dpnId != null && rd.equals(dpnId.toString())) {
return false;
}
- if (networkName != null && rd.equals(networkName)) {
+ if (rd.equals(networkName)) {
return false;
}
return true;
return false;
}
- static String getFibFlowRef(BigInteger dpnId, short tableId, String vpnName, int priority) {
+ static String getFibFlowRef(Uint64 dpnId, short tableId, String vpnName, int priority) {
return VpnConstants.FLOWID_PREFIX + dpnId + NwConstants.FLOWID_SEPARATOR + tableId
+ NwConstants.FLOWID_SEPARATOR + vpnName + NwConstants.FLOWID_SEPARATOR + priority;
}
- static void removeExternalTunnelDemuxFlows(String vpnName, DataBroker broker, IMdsalApiManager mdsalManager) {
+ void removeExternalTunnelDemuxFlows(String vpnName) {
LOG.info("Removing external tunnel flows for vpn {}", vpnName);
- for (BigInteger dpnId: NWUtil.getOperativeDPNs(broker)) {
+ for (Uint64 dpnId: NWUtil.getOperativeDPNs(dataBroker)) {
LOG.debug("Removing external tunnel flows for vpn {} from dpn {}", vpnName, dpnId);
String flowRef = getFibFlowRef(dpnId, NwConstants.L3VNI_EXTERNAL_TUNNEL_DEMUX_TABLE,
vpnName, VpnConstants.DEFAULT_FLOW_PRIORITY);
}
}
- public static boolean isVpnPendingDelete(DataBroker broker, String rd) {
- VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(broker, rd);
+ public boolean isVpnPendingDelete(String rd) {
+ VpnInstanceOpDataEntry vpnInstanceOpData = getVpnInstanceOpData(rd);
boolean isVpnPendingDelete = false;
- if (vpnInstanceOpData == null
- || vpnInstanceOpData.getVpnState() == VpnInstanceOpDataEntry.VpnState.PendingDelete) {
+ if (vpnInstanceOpData == null) {
+ LOG.error("isVpnPendingDelete: unable to read vpn instance op data for vpn with rd {}", rd);
+ isVpnPendingDelete = true;
+ }
+ else if (vpnInstanceOpData.getVpnState() == VpnInstanceOpDataEntry.VpnState.PendingDelete) {
isVpnPendingDelete = true;
}
return isVpnPendingDelete;
}
- public static List<VpnInstanceOpDataEntry> getVpnsImportingMyRoute(final DataBroker broker, final String vpnName) {
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public List<VpnInstanceOpDataEntry> getVpnsImportingMyRoute(final String vpnName) {
List<VpnInstanceOpDataEntry> vpnsToImportRoute = new ArrayList<>();
-
- final String vpnRd = getVpnRd(broker, vpnName);
+ final VpnInstanceOpDataEntry vpnInstanceOpDataEntry;
+ final String vpnRd = getVpnRd(vpnName);
if (vpnRd == null) {
LOG.error("getVpnsImportingMyRoute: vpn {} not present in config DS.", vpnName);
return vpnsToImportRoute;
}
- final VpnInstanceOpDataEntry vpnInstanceOpDataEntry = VpnUtil.getVpnInstanceOpData(broker, vpnRd);
- if (vpnInstanceOpDataEntry == null) {
- LOG.error("getVpnsImportingMyRoute: Could not retrieve vpn instance op data for {}"
- + " to check for vpns importing the routes", vpnName);
+ if (vpnRd.equals(vpnName)) {
+ LOG.error("getVpnsImportingMyRoute: Internal vpn {} do not export/import routes", vpnName);
+ return vpnsToImportRoute;
+ }
+ try {
+ final VpnInstanceOpDataEntry opDataEntry = getVpnInstanceOpData(vpnRd);
+ if (opDataEntry == null) {
+ LOG.error("getVpnsImportingMyRoute: Could not retrieve vpn instance op data for vpn {} rd {}"
+ + " to check for vpns importing the routes", vpnName, vpnRd);
+ return vpnsToImportRoute;
+ }
+ vpnInstanceOpDataEntry = opDataEntry;
+ } catch (Exception e) {
+ LOG.error("getVpnsImportingMyRoute: DSException when retrieving vpn instance op data for vpn {} rd {}"
+ + " to check for vpns importing the routes", vpnName, vpnRd);
return vpnsToImportRoute;
}
-
Predicate<VpnInstanceOpDataEntry> excludeVpn = input -> {
if (input.getVpnInstanceName() == null) {
LOG.error("getVpnsImportingMyRoute.excludeVpn: Received vpn instance with rd {} without a name.",
}
return !input.getVpnInstanceName().equals(vpnName);
};
-
Predicate<VpnInstanceOpDataEntry> matchRTs = input -> {
Iterable<String> commonRTs =
intersection(getRts(vpnInstanceOpDataEntry, VpnTarget.VrfRTType.ExportExtcommunity),
getRts(input, VpnTarget.VrfRTType.ImportExtcommunity));
return Iterators.size(commonRTs.iterator()) > 0;
};
-
- vpnsToImportRoute = getAllVpnInstanceOpData(broker)
- .stream()
- .filter(excludeVpn)
- .filter(matchRTs)
+ vpnsToImportRoute = getAllVpnInstanceOpData().stream().filter(excludeVpn).filter(matchRTs)
.collect(Collectors.toList());
return vpnsToImportRoute;
}
- public static List<String> getRts(VpnInstanceOpDataEntry vpnInstance, VpnTarget.VrfRTType rtType) {
+ static List<String> getRts(VpnInstanceOpDataEntry vpnInstance, VpnTarget.VrfRTType rtType) {
String name = vpnInstance.getVpnInstanceName();
List<String> rts = new ArrayList<>();
VpnTargets targets = vpnInstance.getVpnTargets();
if (targets == null) {
- LOG.info("getRts: vpn targets not available for {}", name);
+ LOG.debug("getRts: vpn targets not available for {}", name);
return rts;
}
List<VpnTarget> vpnTargets = targets.getVpnTarget();
if (vpnTargets == null) {
- LOG.info("getRts: vpnTarget values not available for {}", name);
+ LOG.debug("getRts: vpnTarget values not available for {}", name);
return rts;
}
for (VpnTarget target : vpnTargets) {
return rts;
}
- public static <T> Iterable<T> intersection(final Collection<T> collection1, final Collection<T> collection2) {
+ static <T> Iterable<T> intersection(final Collection<T> collection1, final Collection<T> collection2) {
Set<T> intersection = new HashSet<>(collection1);
intersection.retainAll(collection2);
return intersection;
}
/** Get Subnetmap from its Uuid.
- * @param broker the data broker for look for data
* @param subnetUuid the subnet's Uuid
* @return the Subnetmap of Uuid or null if it is not found
*/
- public static Subnetmap getSubnetmapFromItsUuid(DataBroker broker, Uuid subnetUuid) {
- Subnetmap sn = null;
+ @Nullable
+ public Subnetmap getSubnetmapFromItsUuid(Uuid subnetUuid) {
InstanceIdentifier<Subnetmap> id = buildSubnetmapIdentifier(subnetUuid);
- Optional<Subnetmap> optionalSn = read(broker, LogicalDatastoreType.CONFIGURATION, id);
- if (optionalSn.isPresent()) {
- sn = optionalSn.get();
- }
- return sn;
+ return read(LogicalDatastoreType.CONFIGURATION, id).orNull();
}
- public static boolean isSubnetPartOfVpn(Subnetmap sn, String vpnName) {
- if (vpnName == null || sn == null || sn.getVpnId() == null) {
- return false;
- }
- if (sn.getVpnId().getValue().equals(vpnName)) {
- return true;
- } else if (sn.getInternetVpnId() != null
- && sn.getInternetVpnId().getValue().equals(vpnName)) {
- return true;
- }
- return false;
- }
-
- public static boolean isAdjacencyEligibleToVpnInternet(DataBroker dataBroker, Adjacency adjacency) {
+ boolean isAdjacencyEligibleToVpnInternet(Adjacency adjacency) {
// returns true if BGPVPN Internet and adjacency is IPv6, false otherwise
- boolean adjacencyEligible = true;
- if (adjacency.getAdjacencyType() == AdjacencyType.ExtraRoute) {
- if (FibHelper.isIpv6Prefix(adjacency.getIpAddress())) {
- return adjacencyEligible;
+ boolean adjacencyEligible = false;
+ IpVersionChoice ipVerChoice = getIpVersionFromString(adjacency.getIpAddress());
+ if (ipVerChoice.isIpVersionChosen(IpVersionChoice.IPV6)) {
+ Subnetmap sn = getSubnetmapFromItsUuid(adjacency.getSubnetId());
+ if (sn != null && sn.getInternetVpnId() != null) {
+ adjacencyEligible = true;
}
- return false;
- } else if (adjacency.getSubnetId() == null) {
- return adjacencyEligible;
- }
- Subnetmap sn = VpnUtil.getSubnetmapFromItsUuid(
- dataBroker, adjacency.getSubnetId());
- if (sn != null && sn.getInternetVpnId() != null) {
- adjacencyEligible = false;
}
return adjacencyEligible;
}
- public static boolean isAdjacencyEligibleToVpn(DataBroker dataBroker, Adjacency adjacency,
- String vpnName) {
+ boolean isAdjacencyEligibleToVpn(Adjacency adjacency, String vpnName) {
// returns true if BGPVPN Internet and adjacency is IPv6, false otherwise
boolean adjacencyEligible = true;
// if BGPVPN internet, return false if subnetmap has not internetVpnId() filled in
- if (isBgpVpnInternet(dataBroker, vpnName)) {
- return isAdjacencyEligibleToVpnInternet(dataBroker, adjacency);
+ if (isBgpVpnInternet(vpnName)) {
+ return isAdjacencyEligibleToVpnInternet(adjacency);
}
return adjacencyEligible;
}
- public static String getInternetVpnFromVpnInstanceList(DataBroker dataBroker,
- List<VpnInstanceNames> vpnInstanceList) {
+ @Nullable
+ String getInternetVpnFromVpnInstanceList(List<VpnInstanceNames> vpnInstanceList) {
for (VpnInstanceNames vpnInstance : vpnInstanceList) {
String vpnName = vpnInstance.getVpnName();
- if (isBgpVpnInternet(dataBroker, vpnName)) {
+ if (isBgpVpnInternet(vpnName)) {
return vpnName;
}
}
}
/** Get boolean true if vpn is bgpvpn internet, false otherwise.
- * @param dataBroker databroker for transaction
* @param vpnName name of the input VPN
* @return true or false
*/
- public static boolean isBgpVpnInternet(DataBroker dataBroker, String vpnName) {
- String primaryRd = getVpnRd(dataBroker, vpnName);
+ boolean isBgpVpnInternet(String vpnName) {
+ String primaryRd = getVpnRd(vpnName);
if (primaryRd == null) {
LOG.error("isBgpVpnInternet VPN {}."
+ "Primary RD not found", vpnName);
InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier.builder(VpnInstanceOpData.class)
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(primaryRd)).build();
- Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional =
- read(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
+ Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional = read(LogicalDatastoreType.OPERATIONAL, id);
if (!vpnInstanceOpDataEntryOptional.isPresent()) {
LOG.error("isBgpVpnInternet VPN {}."
+ "VpnInstanceOpDataEntry not found", vpnName);
* @return the IpVersionChoice of the version or IpVersionChoice.UNDEFINED otherwise
*/
public static IpVersionChoice getIpVersionFromString(String ipAddress) {
- IpVersionChoice ipchoice = IpVersionChoice.UNDEFINED;
int indexIpAddress = ipAddress.indexOf('/');
if (indexIpAddress >= 0) {
ipAddress = ipAddress.substring(0, indexIpAddress);
return IpVersionChoice.IPV6;
}
} catch (UnknownHostException | SecurityException e) {
- ipchoice = IpVersionChoice.UNDEFINED;
+ return IpVersionChoice.UNDEFINED;
}
- return ipchoice;
+ return IpVersionChoice.UNDEFINED;
}
- public static ListenableFuture<Void> unsetScheduledToRemoveForVpnInterface(ManagedNewTransactionRunner txRunner,
- String interfaceName) {
- VpnInterfaceBuilder builder = new VpnInterfaceBuilder().setKey(new VpnInterfaceKey(interfaceName))
- .setScheduledForRemove(false);
- return txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx -> tx.merge(LogicalDatastoreType.OPERATIONAL,
+ ListenableFuture<Void> unsetScheduledToRemoveForVpnInterface(String interfaceName) {
+ VpnInterfaceBuilder builder = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(interfaceName));
+ return txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> tx.merge(
VpnUtil.getVpnInterfaceIdentifier(interfaceName), builder.build(),
WriteTransaction.CREATE_MISSING_PARENTS));
}
*
* @param vpnName the vpnName
* @param dpnId the DPN id
- * @param dataBroker the data Broker
*/
- public static void addRouterPortToElanForVlanInDpn(String vpnName, BigInteger dpnId , DataBroker dataBroker) {
- Map<String,String> elanInstanceRouterPortMap = VpnUtil.getElanInstanceRouterPortMap(dataBroker, vpnName);
+ void addRouterPortToElanForVlanInDpn(String vpnName, Uint64 dpnId) {
+ Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
- addRouterPortToElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(),
- vpnName, dpnId, dataBroker);
+ addRouterPortToElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(), dpnId);
}
}
*
* @param vpnName the vpn name
* @param dpnId the DPN id
- * @param dataBroker the data Broker
*/
- public static void removeRouterPortFromElanForVlanInDpn(String vpnName, BigInteger dpnId , DataBroker dataBroker) {
- Map<String,String> elanInstanceRouterPortMap = VpnUtil.getElanInstanceRouterPortMap(dataBroker, vpnName);
+ void removeRouterPortFromElanForVlanInDpn(String vpnName, Uint64 dpnId) {
+ Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
removeRouterPortFromElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(),
- vpnName, dpnId, dataBroker);
+ vpnName, dpnId);
}
}
* This will create the vlan footprint in all the DPN's which are member of the VPN.
*
* @param vpnName the vpn name
- * @param dataBroker the data broker
*/
- public static void addRouterPortToElanDpnListForVlaninAllDpn(String vpnName, DataBroker dataBroker) {
- Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(dataBroker, vpnName);
- Set<BigInteger> dpnList = getDpnInElan(dataBroker, elanInstanceRouterPortMap);
- for (BigInteger dpnId : dpnList) {
+ void addRouterPortToElanDpnListForVlaninAllDpn(String vpnName) {
+ Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
+ Set<Uint64> dpnList = getDpnInElan(elanInstanceRouterPortMap);
+ for (Uint64 dpnId : dpnList) {
for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
- addRouterPortToElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(),
- vpnName, dpnId, dataBroker);
+ addRouterPortToElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(), dpnId);
}
}
}
* @param routerInterfacePortId this will add the current subnet router port id to the map for removal
* @param elanInstanceName the current elanstance being removed this will be added to map for removal
* @param vpnName the vpn name
- * @param dataBroker the databroker
*/
- public static void removeRouterPortFromElanDpnListForVlanInAllDpn(String elanInstanceName,
- String routerInterfacePortId, String vpnName, DataBroker dataBroker) {
- Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(dataBroker, vpnName);
+ void removeRouterPortFromElanDpnListForVlanInAllDpn(String elanInstanceName,
+ String routerInterfacePortId, String vpnName) {
+ Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
elanInstanceRouterPortMap.put(elanInstanceName, routerInterfacePortId);
- Set<BigInteger> dpnList = getDpnInElan(dataBroker, elanInstanceRouterPortMap);
- for (BigInteger dpnId : dpnList) {
+ Set<Uint64> dpnList = getDpnInElan(elanInstanceRouterPortMap);
+ for (Uint64 dpnId : dpnList) {
for (Entry<String, String> elanInstanceRouterEntry : elanInstanceRouterPortMap.entrySet()) {
removeRouterPortFromElanDpn(elanInstanceRouterEntry.getKey(), elanInstanceRouterEntry.getValue(),
- vpnName, dpnId, dataBroker);
+ vpnName, dpnId);
}
}
}
- public static Set<BigInteger> getDpnInElan(DataBroker dataBroker, Map<String,String> elanInstanceRouterPortMap) {
- Set<BigInteger> dpnIdSet = new HashSet<BigInteger>();
+ Set<Uint64> getDpnInElan(Map<String,String> elanInstanceRouterPortMap) {
+ Set<Uint64> dpnIdSet = new HashSet<>();
for (String elanInstanceName : elanInstanceRouterPortMap.keySet()) {
InstanceIdentifier<ElanDpnInterfacesList> elanDpnInterfaceId = getElanDpnOperationalDataPath(
elanInstanceName);
- Optional<ElanDpnInterfacesList> dpnInElanInterfaces = VpnUtil.read(dataBroker,
- LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
+ Optional<ElanDpnInterfacesList> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL,
+ elanDpnInterfaceId);
if (dpnInElanInterfaces.isPresent()) {
- List<DpnInterfaces> dpnInterfaces = dpnInElanInterfaces.get().getDpnInterfaces();
+ List<DpnInterfaces> dpnInterfaces = dpnInElanInterfaces.get().nonnullDpnInterfaces();
for (DpnInterfaces dpnInterface : dpnInterfaces) {
dpnIdSet.add(dpnInterface.getDpId());
}
return dpnIdSet;
}
- public static void addRouterPortToElanDpn(String elanInstanceName, String routerInterfacePortId, String vpnName,
- BigInteger dpnId, DataBroker dataBroker) {
+ void addRouterPortToElanDpn(String elanInstanceName, String routerInterfacePortId, Uint64 dpnId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfaceId = getElanDpnInterfaceOperationalDataPath(
elanInstanceName,dpnId);
- Optional<DpnInterfaces> dpnInElanInterfaces = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- elanDpnInterfaceId);
- List<String> elanInterfaceList;
- DpnInterfaces dpnInterface;
- if (!dpnInElanInterfaces.isPresent()) {
- elanInterfaceList = new ArrayList<>();
- } else {
- dpnInterface = dpnInElanInterfaces.get();
- elanInterfaceList = dpnInterface.getInterfaces();
- }
- if (!elanInterfaceList.contains(routerInterfacePortId)) {
- elanInterfaceList.add(routerInterfacePortId);
- dpnInterface = new DpnInterfacesBuilder().setDpId(dpnId).setInterfaces(elanInterfaceList)
- .setKey(new DpnInterfacesKey(dpnId)).build();
- VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
- elanDpnInterfaceId, dpnInterface);
+ final ReentrantLock lock = JvmGlobalLocks.getLockForString(elanInstanceName);
+ lock.lock();
+ try {
+ Optional<DpnInterfaces> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
+ List<String> elanInterfaceList = new ArrayList<>();
+ DpnInterfaces dpnInterface;
+ if (!dpnInElanInterfaces.isPresent()) {
+ elanInterfaceList = new ArrayList<>();
+ } else {
+ dpnInterface = dpnInElanInterfaces.get();
+ elanInterfaceList = (dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty())
+ ? new ArrayList<>(dpnInterface.getInterfaces()) : elanInterfaceList;
+ }
+ if (!elanInterfaceList.contains(routerInterfacePortId)) {
+ elanInterfaceList.add(routerInterfacePortId);
+ dpnInterface = new DpnInterfacesBuilder().setDpId(dpnId).setInterfaces(elanInterfaceList)
+ .withKey(new DpnInterfacesKey(dpnId)).build();
+ syncWrite(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId, dpnInterface);
+ }
+ } finally {
+ lock.unlock();
}
-
}
- public static void removeRouterPortFromElanDpn(String elanInstanceName, String routerInterfacePortId,
- String vpnName, BigInteger dpnId, DataBroker dataBroker) {
+ void removeRouterPortFromElanDpn(String elanInstanceName, String routerInterfacePortId,
+ String vpnName, Uint64 dpnId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfaceId = getElanDpnInterfaceOperationalDataPath(
elanInstanceName,dpnId);
- Optional<DpnInterfaces> dpnInElanInterfaces = VpnUtil.read(dataBroker, LogicalDatastoreType.OPERATIONAL,
- elanDpnInterfaceId);
- List<String> elanInterfaceList;
- DpnInterfaces dpnInterface;
- if (!dpnInElanInterfaces.isPresent()) {
- LOG.info("No interface in any dpn for {}", vpnName);
- return;
- } else {
- dpnInterface = dpnInElanInterfaces.get();
- elanInterfaceList = dpnInterface.getInterfaces();
- }
- if (!elanInterfaceList.contains(routerInterfacePortId)) {
- LOG.info("Router port not present in DPN {} for VPN {}", dpnId, vpnName);
- return;
+ final ReentrantLock lock = JvmGlobalLocks.getLockForString(elanInstanceName);
+ lock.lock();
+ try {
+ Optional<DpnInterfaces> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId);
+ List<String> elanInterfaceList = new ArrayList<>();
+ DpnInterfaces dpnInterface;
+ if (!dpnInElanInterfaces.isPresent()) {
+ LOG.info("No interface in any dpn for {}", vpnName);
+ return;
+ } else {
+ dpnInterface = dpnInElanInterfaces.get();
+ elanInterfaceList = (dpnInterface.getInterfaces() != null && !dpnInterface.getInterfaces().isEmpty())
+ ? new ArrayList<>(dpnInterface.getInterfaces()) : elanInterfaceList;
+ }
+ if (!elanInterfaceList.contains(routerInterfacePortId)) {
+ LOG.info("Router port not present in DPN {} for VPN {}", dpnId, vpnName);
+ return;
+ }
+ elanInterfaceList.remove(routerInterfacePortId);
+ dpnInterface = new DpnInterfacesBuilder().setDpId(dpnId).setInterfaces(elanInterfaceList)
+ .withKey(new DpnInterfacesKey(dpnId)).build();
+ syncWrite(LogicalDatastoreType.OPERATIONAL, elanDpnInterfaceId, dpnInterface);
+ } finally {
+ lock.unlock();
}
- elanInterfaceList.remove(routerInterfacePortId);
- dpnInterface = new DpnInterfacesBuilder().setDpId(dpnId).setInterfaces(elanInterfaceList)
- .setKey(new DpnInterfacesKey(dpnId)).build();
- VpnUtil.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
- elanDpnInterfaceId, dpnInterface);
}
- public static ElanInterface getElanInterfaceByElanInterfaceName(DataBroker broker, String elanInterfaceName) {
+ @Nullable
+ ElanInterface getElanInterfaceByElanInterfaceName(String elanInterfaceName) {
InstanceIdentifier<ElanInterface> elanInterfaceId = getElanInterfaceConfigurationDataPathId(elanInterfaceName);
- return read(broker, LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orNull();
}
- public static InstanceIdentifier<ElanInterface> getElanInterfaceConfigurationDataPathId(String interfaceName) {
+ static InstanceIdentifier<ElanInterface> getElanInterfaceConfigurationDataPathId(String interfaceName) {
return InstanceIdentifier.builder(ElanInterfaces.class)
.child(ElanInterface.class, new ElanInterfaceKey(interfaceName)).build();
}
- public static Optional<Interface> getInterface(DataBroker broker, String interfaceName) {
- return read(broker, LogicalDatastoreType.CONFIGURATION, getInterfaceIdentifier(interfaceName));
- }
-
- public static DpnInterfaces getElanInterfaceInfoByElanDpn(DataBroker broker, String elanInstanceName,
- BigInteger dpId) {
+ @Nullable
+ DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, Uint64 dpId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfacesId = getElanDpnInterfaceOperationalDataPath(elanInstanceName,
dpId);
- return read(broker, LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orNull();
+ return read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orNull();
}
- public static String getExternalElanInterface(DataBroker broker, String elanInstanceName, BigInteger dpnId,
- IInterfaceManager interfaceManager) {
- DpnInterfaces dpnInterfaces = getElanInterfaceInfoByElanDpn(broker, elanInstanceName, dpnId);
+ @Nullable
+ String getExternalElanInterface(String elanInstanceName, Uint64 dpnId) {
+ DpnInterfaces dpnInterfaces = getElanInterfaceInfoByElanDpn(elanInstanceName, dpnId);
if (dpnInterfaces == null || dpnInterfaces.getInterfaces() == null) {
LOG.info("Elan {} does not have interfaces in DPN {}", elanInstanceName, dpnId);
return null;
return null;
}
- public static boolean isVlan(ElanInstance elanInstance) {
+ static boolean isVlan(ElanInstance elanInstance) {
return elanInstance != null && elanInstance.getSegmentType() != null
&& elanInstance.getSegmentType().isAssignableFrom(SegmentTypeVlan.class)
- && elanInstance.getSegmentationId() != null && elanInstance.getSegmentationId() != 0;
+ && elanInstance.getSegmentationId() != null && elanInstance.getSegmentationId().toJava() != 0;
}
- public static boolean isVlan(DataBroker databroker , String interfaceName) {
- ElanInterface elanInterface = getElanInterfaceByElanInterfaceName(databroker, interfaceName);
+ boolean isVlan(String interfaceName) {
+ ElanInterface elanInterface = getElanInterfaceByElanInterfaceName(interfaceName);
if (elanInterface == null) {
return false;
}
- ElanInstance elanInstance = getElanInstanceByName(databroker, elanInterface.getElanInstanceName());
+ ElanInstance elanInstance = getElanInstanceByName(elanInterface.getElanInstanceName());
return isVlan(elanInstance);
}
- public static ElanInstance getElanInstanceByName(DataBroker broker, String elanInstanceName) {
+ @Nullable
+ ElanInstance getElanInstanceByName(String elanInstanceName) {
InstanceIdentifier<ElanInstance> elanIdentifierId =
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName);
- return read(broker, LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
+ return read(LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
}
- public static String getVpnNameFromElanIntanceName(DataBroker dataBroker, String elanInstanceName) {
- Optional<Subnetmaps> subnetMapsData =
- read(dataBroker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
+ @Nullable
+ String getVpnNameFromElanIntanceName(String elanInstanceName) {
+ Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
if (subnetMapList != null && !subnetMapList.isEmpty()) {
return null;
}
- public static Map<String, String> getElanInstanceRouterPortMap(DataBroker dataBroker, String vpnName) {
- Map<String, String> elanInstanceRouterPortMap = new HashMap<String, String>();
- Optional<Subnetmaps> subnetMapsData =
- read(dataBroker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
+ Map<String, String> getElanInstanceRouterPortMap(String vpnName) {
+ Map<String, String> elanInstanceRouterPortMap = new HashMap<>();
+ Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
- List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
+ List<Subnetmap> subnetMapList = new ArrayList<>();
+ Subnetmaps subnetMaps = subnetMapsData.get();
+ subnetMapList = (subnetMaps.getSubnetmap() != null && !subnetMaps.getSubnetmap().isEmpty())
+ ? new ArrayList<>(subnetMaps.getSubnetmap()) : subnetMapList;
+
if (subnetMapList != null && !subnetMapList.isEmpty()) {
for (Subnetmap subnet : subnetMapList) {
if (subnet.getVpnId() != null && subnet.getVpnId().getValue().equals(vpnName)
- && subnet.getNetworkType().equals(NetworkType.VLAN)) {
+ && NetworkType.VLAN.equals(subnet.getNetworkType())) {
if (subnet.getRouterInterfacePortId() == null || subnet.getNetworkId() == null) {
LOG.warn("The RouterInterfacePortId or NetworkId is null");
continue;
return elanInstanceRouterPortMap;
}
- public static String getRouterPordIdFromElanInstance(DataBroker dataBroker, String elanInstanceName) {
- Optional<Subnetmaps> subnetMapsData =
- read(dataBroker, LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
+ @Nullable
+ String getRouterPordIdFromElanInstance(String elanInstanceName) {
+ Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
List<Subnetmap> subnetMapList = subnetMapsData.get().getSubnetmap();
if (subnetMapList != null && !subnetMapList.isEmpty()) {
return null;
}
- public static boolean shouldPopulateFibForVlan(DataBroker dataBroker, String vpnName, String elanInstanceName,
- BigInteger dpnId, IInterfaceManager interfaceManager) {
- Map<String,String> elanInstanceRouterPortMap = VpnUtil
- .getElanInstanceRouterPortMap(dataBroker, vpnName);
+ boolean shouldPopulateFibForVlan(String vpnName, @Nullable String elanInstanceName, Uint64 dpnId) {
+ Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
boolean shouldPopulateFibForVlan = false;
if (!elanInstanceRouterPortMap.isEmpty()) {
shouldPopulateFibForVlan = true;
if (elanInstanceName != null && elanInstanceName.equals(currentElanInstance)) {
continue;
}
- String externalinterface = VpnUtil.getExternalElanInterface(dataBroker,
- currentElanInstance ,dpnId,
- interfaceManager);
+ String externalinterface = getExternalElanInterface(currentElanInstance ,dpnId);
if (externalinterface == null) {
shouldPopulateFibForVlan = false;
break;
}
public static InstanceIdentifier<DpnInterfaces> getElanDpnInterfaceOperationalDataPath(String elanInstanceName,
- BigInteger dpId) {
+ Uint64 dpId) {
return InstanceIdentifier.builder(ElanDpnInterfaces.class)
.child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName))
.child(DpnInterfaces.class, new DpnInterfacesKey(dpId)).build();
.child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName))
.build();
}
+
+ public static boolean isMatchedPrefixToInterface(Prefixes prefix, VpnInterfaceOpDataEntry vpnInterface) {
+ if (prefix != null && vpnInterface != null) {
+ if (prefix.getDpnId() != null && vpnInterface.getDpnId() != null) {
+ if (prefix.getVpnInterfaceName() != null && vpnInterface.getName() != null) {
+ return prefix.getDpnId().equals(vpnInterface.getDpnId())
+ && prefix.getVpnInterfaceName().equalsIgnoreCase(vpnInterface.getName());
+ }
+ }
+ }
+ return false;
+ }
+
+ public static void sendNeighborSolicationToOfGroup(Ipv6NdUtilService ipv6NdUtilService, Ipv6Address srcIpv6Address,
+ MacAddress srcMac, Ipv6Address dstIpv6Address, Long ofGroupId, Uint64 dpId) {
+ SendNeighborSolicitationToOfGroupInput input = new SendNeighborSolicitationToOfGroupInputBuilder()
+ .setSourceIpv6(srcIpv6Address).setSourceLlAddress(srcMac).setTargetIpAddress(dstIpv6Address)
+ .setOfGroupId(ofGroupId).setDpId(dpId).build();
+ try {
+ Future<RpcResult<SendNeighborSolicitationToOfGroupOutput>> result = ipv6NdUtilService
+ .sendNeighborSolicitationToOfGroup(input);
+ RpcResult<SendNeighborSolicitationToOfGroupOutput> rpcResult = result.get();
+ if (!rpcResult.isSuccessful()) {
+ LOG.error("sendNeighborSolicitationToOfGroup: RPC Call failed for input={} and Errors={}", input,
+ rpcResult.getErrors());
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Failed to send NS packet to ELAN group, input={}", input, e);
+ }
+ }
+
+ static Set<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.vpn
+ .instance.vpntargets.VpnTarget> getRtListForVpn(DataBroker dataBroker, String vpnName) {
+ Set<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.vpn
+ .instance.vpntargets.VpnTarget> rtList = new HashSet<>();
+ try {
+ InstanceIdentifier<VpnInstance> vpnInstanceId = InstanceIdentifier.builder(VpnInstances.class)
+ .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
+ Optional<VpnInstance> vpnInstanceOptional = SingleTransactionDataBroker.syncReadOptional(dataBroker,
+ LogicalDatastoreType.CONFIGURATION, vpnInstanceId);
+ if (vpnInstanceOptional.isPresent()) {
+ org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances
+ .vpn.instance.VpnTargets vpnTargets = vpnInstanceOptional.get().getVpnTargets();
+ if (vpnTargets != null && vpnTargets.getVpnTarget() != null) {
+ rtList.addAll(vpnTargets.getVpnTarget());
+ }
+ } else {
+ LOG.error("getRtListForVpn: Vpn Instance {} not present in config DS", vpnName);
+ }
+ } catch (ReadFailedException e) {
+ LOG.error("getRtListForVpn: Read failed for Vpn Instance {}", vpnName);
+ }
+ return rtList;
+ }
+
+ /*
+ if (update == 0) {
+ removedFamily = original
+ 4 removed = 4
+ 6 removed = 6
+ 10 removed
+ } else if (update < original) {
+ removedFamily = original - update
+ 10 was there 4 removed = 6
+ 10 was there 6 removed = 4
+ } else {
+ return;
+ }
+ */
+ public static int getIpFamilyValueToRemove(VpnInstanceOpDataEntry original, VpnInstanceOpDataEntry update) {
+ int originalValue = original.getIpAddressFamilyConfigured().getIntValue();
+ int updatedValue = update.getIpAddressFamilyConfigured().getIntValue();
+
+ if (originalValue == updatedValue) {
+ return 0;
+ }
+ int removedFamily;
+ if (updatedValue == 0) {
+ removedFamily = originalValue;
+ } else if (updatedValue < originalValue) {
+ removedFamily = originalValue - updatedValue;
+ } else {
+ return 0;
+ }
+ return removedFamily;
+ }
+
+ public static int getIpFamilyValueToAdd(VpnInstanceOpDataEntry original, VpnInstanceOpDataEntry update) {
+ int originalValue = original.getIpAddressFamilyConfigured().getIntValue();
+ int updatedValue = update.getIpAddressFamilyConfigured().getIntValue();
+
+ if (originalValue != updatedValue) {
+ return updatedValue;
+ } else {
+ return originalValue;
+ }
+ }
+
+ static InstanceIdentifier<AssociatedVpn> getAssociatedSubnetAndVpnIdentifier(String rt, RouteTarget.RtType rtType,
+ String cidr, String vpnName) {
+ return InstanceIdentifier.builder(SubnetsAssociatedToRouteTargets.class).child(RouteTarget.class,
+ new RouteTargetKey(rt, rtType)).child(AssociatedSubnet.class, new AssociatedSubnetKey(cidr))
+ .child(AssociatedVpn.class, new AssociatedVpnKey(vpnName)).build();
+ }
+
+ static InstanceIdentifier<AssociatedSubnet> getAssociatedSubnetIdentifier(String rt, RouteTarget.RtType rtType,
+ String cidr) {
+ return InstanceIdentifier.builder(SubnetsAssociatedToRouteTargets.class).child(RouteTarget.class,
+ new RouteTargetKey(rt, rtType)).child(AssociatedSubnet.class, new AssociatedSubnetKey(cidr)).build();
+ }
+
+ static AssociatedVpn buildAssociatedSubnetAndVpn(String vpnName) {
+ return new AssociatedVpnBuilder().setName(vpnName).build();
+ }
+
+ static InstanceIdentifier<RouteTarget> getRouteTargetsIdentifier(String rt, RouteTarget.RtType rtType) {
+ return InstanceIdentifier.builder(SubnetsAssociatedToRouteTargets.class)
+ .child(RouteTarget.class, new RouteTargetKey(rt, rtType)).build();
+ }
+
+ Set<RouteTarget> getRouteTargetSet(Set<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn
+ .rev200204.vpn.instances.vpn.instance.vpntargets.VpnTarget> vpnTargets) {
+ Set<RouteTarget> routeTargetSet = new HashSet<>();
+ for (org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.l3vpn.rev200204.vpn.instances.vpn
+ .instance.vpntargets.VpnTarget rt : vpnTargets) {
+ String rtValue = rt.getVrfRTValue();
+ switch (rt.getVrfRTType()) {
+ case ImportExtcommunity: {
+ Optional<RouteTarget> exportRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
+ getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.ERT));
+ if (exportRouteTargetOptional.isPresent()) {
+ routeTargetSet.add(exportRouteTargetOptional.get());
+ }
+ break;
+ }
+ case ExportExtcommunity: {
+ Optional<RouteTarget> importRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
+ getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.IRT));
+ if (importRouteTargetOptional.isPresent()) {
+ routeTargetSet.add(importRouteTargetOptional.get());
+ }
+ break;
+ }
+ case Both: {
+ Optional<RouteTarget> exportRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
+ getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.ERT));
+ if (exportRouteTargetOptional.isPresent()) {
+ routeTargetSet.add(exportRouteTargetOptional.get());
+ }
+ Optional<RouteTarget> importRouteTargetOptional = read(LogicalDatastoreType.OPERATIONAL,
+ getRouteTargetsIdentifier(rtValue, RouteTarget.RtType.IRT));
+ if (importRouteTargetOptional.isPresent()) {
+ routeTargetSet.add(importRouteTargetOptional.get());
+ }
+ break;
+ }
+ default:
+ LOG.error("getRouteTargetSet: Invalid rt-type {}", rt.getVrfRTType());
+ }
+ }
+ return routeTargetSet;
+ }
+
+ /*
+ TODO: (vivek/kiran): Subnet overlap in a VPN detection logic should use subnet allocation pools if available
+ rather than only CIDR.
+ Also the Subnet overlap in a VPN detection logic to be addressed for router-based-l3vpns.
+ */
+ static boolean areSubnetsOverlapping(String cidr1, String cidr2) {
+ final int slash1 = cidr1.indexOf('/');
+ final int address1 = addressForCidr(cidr1, slash1);
+ final int cidrPart1 = maskForCidr(cidr1, slash1);
+
+ final int slash2 = cidr2.indexOf('/');
+ final int address2 = addressForCidr(cidr2, slash2);
+ final int cidrPart2 = maskForCidr(cidr2, slash2);
+
+ final int comparedValue = cidrPart1 <= cidrPart2 ? compare(address1, cidrPart1, address2)
+ : compare(address2, cidrPart2, address1);
+ return comparedValue == 0;
+ }
+
+ private static int addressForCidr(String cidr, int slash) {
+ return InetAddresses.coerceToInteger(InetAddresses.forString(cidr.substring(0, slash)));
+ }
+
+ private static int maskForCidr(String cidr, int slash) {
+ return Integer.parseInt(cidr.substring(slash + 1));
+ }
+
+ private static int compare(int address, int cidrPart, int address2) {
+ int prefix = address2 & computeNetmask(cidrPart);
+ return address ^ prefix;
+ }
+
+ private static int computeNetmask(int cidrPart) {
+ int netmask = 0;
+ for (int j = 0; j < cidrPart; ++j) {
+ netmask |= 1 << 31 - j;
+ }
+ return netmask;
+ }
+
+ public static String buildIpMonitorJobKey(String ip, String vpnName) {
+ return VpnConstants.IP_MONITOR_JOB_PREFIX_KEY + "-" + vpnName + "-" + ip;
+ }
+
+ public static List<String> getVpnListForVpnInterface(VpnInterface vpnInter) {
+ return vpnInter.nonnullVpnInstanceNames().stream()
+ .map(VpnInstanceNames::getVpnName).collect(Collectors.toList());
+ }
+
+ public void updateVpnInstanceWithRdList(String vpnName, List<String> updatedRdList) {
+ String primaryRd = getVpnRd(vpnName);
+ if (primaryRd == null) {
+ LOG.warn("updateVpnInstanceWithRdList: Unable to retrieve primary RD for the VPN {}. Skip to process "
+ + "the updated RD list {} ", vpnName, updatedRdList);
+ return;
+ }
+ jobCoordinator.enqueueJob("VPN-" + vpnName, () -> {
+ VpnInstanceOpDataEntryBuilder builder = new VpnInstanceOpDataEntryBuilder().setVrfId(primaryRd);
+ builder.setRd(updatedRdList);
+ return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ OPERATIONAL, tx -> {
+ InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier
+ .builder(VpnInstanceOpData.class).child(VpnInstanceOpDataEntry.class,
+ new VpnInstanceOpDataEntryKey(primaryRd)).build();
+ tx.merge(id, builder.build(), false);
+ LOG.debug("updateVpnInstanceWithRdList: Successfully updated the VPN {} with list of RDs {}",
+ vpnName, updatedRdList);
+ }));
+ });
+ }
+
+ public static RouteOrigin getRouteOrigin(AdjacencyType adjacencyType) {
+ RouteOrigin origin = RouteOrigin.LOCAL;
+ switch (adjacencyType) {
+ case PrimaryAdjacency:
+ origin = RouteOrigin.LOCAL;
+ break;
+ case ExtraRoute:
+ origin = RouteOrigin.STATIC;
+ break;
+ case LearntIp:
+ origin = RouteOrigin.DYNAMIC;
+ break;
+ default:
+ LOG.warn("Unknown adjacencyType={}", adjacencyType);
+ }
+ return origin;
+ }
+
+ public static boolean isDualRouterVpnUpdate(List<String> oldVpnListCopy, List<String> newVpnListCopy) {
+ return oldVpnListCopy.size() == 2 && newVpnListCopy.size() == 3
+ || oldVpnListCopy.size() == 3 && newVpnListCopy.size() == 2;
+ }
+
+ // TODO Clean up the exception handling
+ @SuppressWarnings("checkstyle:IllegalCatch")
+ public void createVpnPortFixedIpToPort(String vpnName, String fixedIp,
+ String portName, boolean isLearntIp, String macAddress,
+ WriteTransaction writeConfigTxn) {
+ InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
+ VpnPortipToPortBuilder builder = new VpnPortipToPortBuilder().withKey(new VpnPortipToPortKey(fixedIp, vpnName))
+ .setVpnName(vpnName).setPortFixedip(fixedIp).setPortName(portName)
+ .setLearntIp(isLearntIp).setSubnetIp(false).setMacAddress(macAddress.toLowerCase(Locale.getDefault()));
+ try {
+ if (writeConfigTxn != null) {
+ writeConfigTxn.put(LogicalDatastoreType.CONFIGURATION, id, builder.build());
+ } else {
+ syncWrite(LogicalDatastoreType.CONFIGURATION, id, builder.build());
+ }
+ LOG.trace("Port with Ip: {}, vpn {}, interface {}, learntIp {} added to VpnPortipToPort DS",
+ fixedIp, vpnName, portName, isLearntIp);
+ } catch (Exception e) {
+ LOG.error("Failure while creating VpnPortIpToPort map for vpn {} learnIp{}", vpnName, fixedIp, e);
+ }
+ }
+
+ protected VpnPortipToPort getVpnPortipToPort(String vpnName, String fixedIp) {
+ InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
+ Optional<VpnPortipToPort> vpnPortipToPortData = read(LogicalDatastoreType.CONFIGURATION, id);
+ if (vpnPortipToPortData.isPresent()) {
+ return vpnPortipToPortData.get();
+ }
+ LOG.error("getVpnPortipToPort: Failed as vpnPortipToPortData DS is absent for VPN {} and fixed IP {}",
+ vpnName, fixedIp);
+ return null;
+ }
+
+ public static void enableArpLearning(Boolean isArpLearningEnabled) {
+ arpLearningEnabled = isArpLearningEnabled;
+ }
+
+ public static Boolean isArpLearningEnabled() {
+ return arpLearningEnabled;
+ }
+
+ private static ReentrantLock lockFor(String vpnName, String fixedIp) {
+ // FIXME: is there some identifier we can use? LearntVpnVipToPortKey perhaps?
+ return JvmGlobalLocks.getLockForString(vpnName + fixedIp);
+ }
}
Code Review / netvirt.git / blobdiff