package org.opendaylight.netvirt.vpnmanager;
+import static java.util.Collections.emptyList;
+import static java.util.Objects.requireNonNull;
+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 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 javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.inject.Singleton;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
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.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.netvirt.vpnmanager.api.VpnHelper;
+import org.opendaylight.netvirt.vpnmanager.iplearn.model.MacEntry;
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.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.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.opendaylight.netvirt.fibmanager.rev150330.fibentries.VrfTablesKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntryKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentrybase.RoutePaths;
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.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.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.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(VpnUtil.class);
- static final int SINGLE_TRANSACTION_BROKER_NO_RETRY = 1;
+ public static final int SINGLE_TRANSACTION_BROKER_NO_RETRY = 1;
private final DataBroker dataBroker;
private final IdManagerService idManager;
+ private final IFibManager fibManager;
private final IBgpManager bgpManager;
private final LockManagerService lockManager;
private final INeutronVpnManager neutronVpnService;
}
}
- public VpnUtil(DataBroker dataBroker, IdManagerService idManager, IBgpManager bgpManager,
- LockManagerService lockManager, INeutronVpnManager neutronVpnService,
- IMdsalApiManager mdsalManager, JobCoordinator jobCoordinator,
- IInterfaceManager interfaceManager, OdlInterfaceRpcService ifmRpcService) {
+ 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;
.child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
}
+ @Nullable
VpnInterface getVpnInterface(String vpnInterfaceName) {
InstanceIdentifier<VpnInterface> id = getVpnInterfaceIdentifier(vpnInterfaceName);
Optional<VpnInterface> vpnInterface = read(LogicalDatastoreType.CONFIGURATION, id);
return InstanceIdentifier.builder(PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build();
}
- static Prefixes getPrefixToInterface(BigInteger dpId, String vpnInterfaceName, String ipPrefix, Uuid subnetId,
+ static Prefixes getPrefixToInterface(BigInteger 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,
Prefixes.PrefixCue prefixCue) {
return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(vpnInterfaceName).setIpAddress(ipPrefix)
- .setSubnetId(subnetId).setPrefixCue(prefixCue).build();
+ .setPrefixCue(prefixCue).build();
}
Optional<Prefixes> getPrefixToInterface(long vpnId, String ipPrefix) {
* @param rd Route-Distinguisher
* @return VrfTables that holds the list of VrfEntries of the specified rd
*/
+ @Nullable
VrfTables getVrfTable(String rd) {
InstanceIdentifier<VrfTables> id = InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class,
new VrfTablesKey(rd)).build();
*/
public List<VrfEntry> getAllVrfEntries(String rd) {
VrfTables vrfTables = getVrfTable(rd);
- return vrfTables != null ? vrfTables.getVrfEntry() : new ArrayList<>();
+ if (vrfTables != null && vrfTables.getVrfEntry() != null) {
+ return vrfTables.getVrfEntry();
+ }
+ return emptyList();
}
//FIXME: Implement caches for DS reads
+ @Nullable
public VpnInstance getVpnInstance(String vpnInstanceName) {
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,
new VpnInstanceKey(vpnInstanceName)).build();
return vpnInstance.isPresent() ? vpnInstance.get() : null;
}
+ @Nonnull
List<VpnInstanceOpDataEntry> getAllVpnInstanceOpData() {
InstanceIdentifier<VpnInstanceOpData> id = InstanceIdentifier.builder(VpnInstanceOpData.class).build();
Optional<VpnInstanceOpData> vpnInstanceOpDataOptional = read(LogicalDatastoreType.OPERATIONAL, id);
- return vpnInstanceOpDataOptional.isPresent() ? vpnInstanceOpDataOptional.get().getVpnInstanceOpDataEntry()
- : Collections.emptyList();
+ return
+ vpnInstanceOpDataOptional.isPresent() && vpnInstanceOpDataOptional.get().getVpnInstanceOpDataEntry() != null
+ ? vpnInstanceOpDataOptional.get().getVpnInstanceOpDataEntry()
+ : emptyList();
}
+ @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,
BigInteger dpnId) {
String primaryRd = getPrimaryRd(vpnInstance);
InstanceIdentifier<VpnToDpnList> dpnToVpnId = VpnHelper.getVpnToDpnListIdentifier(primaryRd, dpnId);
Optional<VpnToDpnList> dpnInVpn = read(LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
- return dpnInVpn.isPresent() ? dpnInVpn.get().getVpnInterfaces() : Collections.emptyList();
+ return dpnInVpn.isPresent() && dpnInVpn.get().getVpnInterfaces() != null ? dpnInVpn.get().getVpnInterfaces()
+ : emptyList();
}
+ @Nonnull
static List<String> getListOfRdsFromVpnInstance(VpnInstance vpnInstance) {
VpnAfConfig vpnConfig = vpnInstance.getIpv4Family();
LOG.trace("vpnConfig {}", vpnConfig);
- return vpnConfig.getRouteDistinguisher() != null ? vpnConfig.getRouteDistinguisher() : Collections.emptyList();
+ return vpnConfig.getRouteDistinguisher() != null && vpnConfig.getRouteDistinguisher() != null
+ ? vpnConfig.getRouteDistinguisher() : emptyList();
}
+ @Nullable
VrfEntry getVrfEntry(String rd, String ipPrefix) {
VrfTables vrfTable = getVrfTable(rd);
// TODO: why check VrfTables if we later go for the specific VrfEntry?
return null;
}
+ @Nullable
public List<Adjacency> getAdjacenciesForVpnInterfaceFromConfig(String intfName) {
final InstanceIdentifier<VpnInterface> identifier = getVpnInterfaceIdentifier(intfName);
InstanceIdentifier<Adjacencies> path = identifier.augmentation(Adjacencies.class);
Optional<Adjacencies> adjacencies = read(LogicalDatastoreType.CONFIGURATION, path);
if (adjacencies.isPresent()) {
- List<Adjacency> nextHops = adjacencies.get().getAdjacency();
- return nextHops;
+ return adjacencies.get().getAdjacency();
}
return null;
}
return new RoutesBuilder().setPrefix(ipPrefix).setNexthopIpList(nextHopList).build();
}
+ @Nullable
String getVpnInterfaceName(BigInteger metadata) throws InterruptedException, ExecutionException {
GetInterfaceFromIfIndexInputBuilder ifIndexInputBuilder = new GetInterfaceFromIfIndexInputBuilder();
BigInteger lportTag = MetaDataUtil.getLportFromMetadata(metadata);
ListenableFutures.addErrorLogging(
new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
Datastore.CONFIGURATION, tx -> {
- for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
+ for (VrfEntry vrfEntry : requireNonNullElse(vrfTables.getVrfEntry(),
+ Collections.<VrfEntry>emptyList())) {
if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
}
List<VrfEntry> matches = new ArrayList<>();
if (vrfTablesOpc.isPresent()) {
VrfTables vrfTables = vrfTablesOpc.get();
- for (VrfEntry vrfEntry : vrfTables.getVrfEntry()) {
- vrfEntry.getRoutePaths().stream()
+ for (VrfEntry vrfEntry : requireNonNullElse(vrfTables.getVrfEntry(), Collections.<VrfEntry>emptyList())) {
+ requireNonNullElse(vrfEntry.getRoutePaths(), Collections.<RoutePaths>emptyList()).stream()
.filter(routePath -> routePath.getNexthopAddress() != null && routePath.getNexthopAddress()
.equals(nexthop)).findFirst().ifPresent(routePath -> matches.add(vrfEntry));
}
});
}
+ 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.debug("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) {
return new VpnInstanceBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).build();
* @param vpnId Dataplane identifier of the VPN
* @return the Vpn instance name
*/
+ @Nullable
String getVpnName(long vpnId) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
.child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
}
+ @Nullable
public VpnInstanceOpDataEntry getVpnInstanceOpData(String rd) {
- InstanceIdentifier<VpnInstanceOpDataEntry> id = getVpnInstanceOpDataIdentifier(rd);
- return read(LogicalDatastoreType.OPERATIONAL, id).orNull();
+ return read(LogicalDatastoreType.OPERATIONAL, getVpnInstanceOpDataIdentifier(rd)).orNull();
}
+ @Nullable
VpnInterface getConfiguredVpnInterface(String interfaceName) {
InstanceIdentifier<VpnInterface> interfaceId = getVpnInterfaceIdentifier(interfaceName);
Optional<VpnInterface> configuredVpnInterface = read(LogicalDatastoreType.CONFIGURATION, interfaceId);
}
public static String getIpPrefix(String prefix) {
- String[] prefixValues = prefix.split("/");
- if (prefixValues.length == 1) {
- prefix = NWUtil.toIpPrefix(prefix);
- }
- return prefix;
+ return prefix.indexOf('/') != -1 ? prefix : NWUtil.toIpPrefix(prefix);
}
static final FutureCallback<Void> DEFAULT_CALLBACK =
}
// interface-index-tag operational container
+ @Nullable
IfIndexInterface getInterfaceInfoByInterfaceTag(long interfaceTag) {
InstanceIdentifier<IfIndexInterface> interfaceId = getInterfaceInfoEntriesOperationalDataPath(interfaceTag);
Optional<IfIndexInterface> existingInterfaceInfo = read(LogicalDatastoreType.OPERATIONAL, interfaceId);
new IfIndexInterfaceKey((int) interfaceTag)).build();
}
+ @Nullable
ElanTagName getElanInfoByElanTag(long elanTag) {
InstanceIdentifier<ElanTagName> elanId = getElanInfoEntriesOperationalDataPath(elanTag);
Optional<ElanTagName> existingElanInfo = read(LogicalDatastoreType.OPERATIONAL, elanId);
new ElanTagNameKey(elanTag)).build();
}
- static void removePrefixToInterfaceForVpnId(long vpnId,
- @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
+ static void removePrefixToInterfaceForVpnId(long 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<Datastore.Operational> operTx) {
+ 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")
- static void removeVpnOpInstance(String vpnName,
- @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
+ 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) {
+ static void removeVpnInstanceToVpnId(String vpnName, @Nonnull TypedWriteTransaction<Configuration> confTx) {
confTx.delete(VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
}
- static void removeVpnIdToVpnInstance(long vpnId,
- @Nonnull TypedWriteTransaction<Configuration> confTx) {
+ static void removeVpnIdToVpnInstance(long vpnId, @Nonnull TypedWriteTransaction<Configuration> confTx) {
confTx.delete(getVpnIdToVpnInstanceIdentifier(vpnId));
}
- static void removeL3nexthopForVpnId(long vpnId,
- @Nonnull TypedWriteTransaction<Datastore.Operational> operTx) {
+ static void removeL3nexthopForVpnId(long 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, BigInteger dpnId,
- String vpnInstanceName,
- TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
+ void scheduleVpnInterfaceForRemoval(String interfaceName, BigInteger dpnId, String vpnInstanceName,
+ @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnInstanceName);
VpnInterfaceOpDataEntry interfaceToUpdate =
}
}
- void createLearntVpnVipToPort(String vpnName, String fixedIp, String
- portName, String macAddress, TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
+ public void createLearntVpnVipToPort(String vpnName, String fixedIp, String portName, String macAddress,
+ TypedWriteTransaction<Operational> writeOperTxn) {
synchronized ((vpnName + fixedIp).intern()) {
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
LearntVpnVipToPortBuilder builder =
}
void removeLearntVpnVipToPort(String vpnName, String fixedIp,
- TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
+ @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
synchronized ((vpnName + fixedIp).intern()) {
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
if (writeOperTxn != null) {
}
protected static void removeVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp,
- TypedWriteTransaction<Configuration> writeConfigTxn) {
+ @Nullable TypedWriteTransaction<Configuration> writeConfigTxn) {
synchronized ((vpnName + fixedIp).intern()) {
InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
if (writeConfigTxn != null) {
public void createLearntVpnVipToPortEvent(String vpnName, String srcIp, String destIP, String portName,
String macAddress, LearntVpnVipToPortEventAction action,
- TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
+ TypedWriteTransaction<Operational> writeOperTxn) {
String eventId = MicroTimestamp.INSTANCE.get();
InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
return id;
}
- void removeLearntVpnVipToPortEvent(String eventId, TypedWriteTransaction<Datastore.Operational> writeOperTxn) {
+ public void removeLearntVpnVipToPortEvent(String eventId,
+ @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
if (writeOperTxn != null) {
writeOperTxn.delete(id);
}
- void removeMipAdjAndLearntIp(String vpnName, String vpnInterface, String prefix) {
+ public void removeMipAdjAndLearntIp(String vpnName, String vpnInterface, String prefix) {
synchronized ((vpnName + prefix).intern()) {
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, prefix);
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
}
}
+ 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);
+ }
+ }
+ }
+
static InstanceIdentifier<NetworkMap> buildNetworkMapIdentifier(Uuid networkId) {
return InstanceIdentifier.builder(NetworkMaps.class).child(NetworkMap.class, new
NetworkMapKey(networkId)).build();
new VpnPortipToPortKey(fixedIp, vpnName)).build();
}
+ @Nullable
public VpnPortipToPort getNeutronPortFromVpnPortFixedIp(String vpnName, String fixedIp) {
InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
Optional<VpnPortipToPort> vpnPortipToPortData = read(LogicalDatastoreType.CONFIGURATION, id);
return null;
}
+ @Nullable
public static VpnPortipToPort getNeutronPortFromVpnPortFixedIp(TypedReadTransaction<Configuration> confTx,
String vpnName, String fixedIp) {
InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
}
}
+ @Nullable
public LearntVpnVipToPort getLearntVpnVipToPort(String vpnName, String fixedIp) {
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
Optional<LearntVpnVipToPort> learntVpnVipToPort = read(LogicalDatastoreType.OPERATIONAL, id);
return result;
}
+ @Nullable
String getAssociatedExternalRouter(String extIp) {
InstanceIdentifier<ExtRouters> extRouterInstanceIndentifier =
InstanceIdentifier.builder(ExtRouters.class).build();
Optional<ExtRouters> extRouterData = read(LogicalDatastoreType.CONFIGURATION, extRouterInstanceIndentifier);
- if (extRouterData.isPresent()) {
- for (Routers routerData : extRouterData.get().getRouters()) {
- List<ExternalIps> externalIps = routerData.getExternalIps();
- for (ExternalIps externalIp : externalIps) {
- if (externalIp.getIpAddress().equals(extIp)) {
- return routerData.getRouterName();
- }
+ 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 : requireNonNullElse(extRouterData.get().getRouters(),
+ Collections.<Routers>emptyList())) {
+ List<ExternalIps> externalIps = requireNonNullElse(routerData.getExternalIps(), emptyList());
+ for (ExternalIps externalIp : externalIps) {
+ if (Objects.equals(externalIp.getIpAddress(), extIp)) {
+ routerName = routerData.getRouterName();
+ break;
}
}
}
- return null;
+
+ if (routerName != null) {
+ return routerName;
+ }
+
+ for (Routers routerData : requireNonNullElse(extRouterData.get().getRouters(),
+ Collections.<Routers>emptyList())) {
+ List<ExternalIps> externalIps = requireNonNullElse(routerData.getExternalIps(), emptyList());
+ 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;
}
static InstanceIdentifier<Routers> buildRouterIdentifier(String routerId) {
return InstanceIdentifier.builder(ExtRouters.class).child(Routers.class, new RoutersKey(routerId)).build();
}
+ @Nullable
Networks getExternalNetwork(Uuid networkId) {
InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
.child(Networks.class, new NetworksKey(networkId)).build();
return optionalNets.isPresent() ? optionalNets.get() : null;
}
+ @Nullable
Uuid getExternalNetworkVpnId(Uuid networkId) {
Networks extNetwork = getExternalNetwork(networkId);
return extNetwork != null ? extNetwork.getVpnid() : null;
}
- List<Uuid> getExternalNetworkRouterIds(Uuid networkId) {
+ @Nonnull
+ public List<Uuid> getExternalNetworkRouterIds(Uuid networkId) {
Networks extNetwork = getExternalNetwork(networkId);
- return extNetwork != null ? extNetwork.getRouterIds() : Collections.emptyList();
+ return extNetwork != null && extNetwork.getRouterIds() != null ? extNetwork.getRouterIds() : emptyList();
}
+ @Nullable
Routers getExternalRouter(String routerId) {
InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class).child(Routers.class,
new RoutersKey(routerId)).build();
return routerData.isPresent() ? routerData.get() : null;
}
+ @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);
}
}
}
- Optional<IpAddress> getIpv4GatewayAddressFromInterface(String srcInterface) {
+ 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) {
- for (FixedIps portIp: port.getFixedIps()) {
- if (portIp.getIpAddress().getIpv6Address() != null) {
- // Skip IPv6 address
- continue;
+ for (FixedIps portIp : port.getFixedIps()) {
+ if (doesInterfaceAndHiddenIpAddressTypeMatch(hiddenIp, portIp)) {
+ gatewayIp =
+ Optional.of(neutronVpnService.getNeutronSubnet(portIp.getSubnetId()).getGatewayIp());
+ break;
}
- gatewayIp = Optional.of(
- neutronVpnService.getNeutronSubnet(portIp.getSubnetId()).getGatewayIp());
}
}
} else {
return gatewayIp;
}
- Optional<String> getGWMacAddressFromInterface(MacEntry macEntry, IpAddress gatewayIp) {
+ 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(macEntry.getVpnName());
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn
LOG.error("getGWMacAddressFromInterface: VPN {} not configured", vpnId);
return gatewayMac;
}
- VpnPortipToPort vpnTargetIpToPort = getNeutronPortFromVpnPortFixedIp(macEntry.getVpnName(),
- gatewayIp.getIpv4Address().getValue());
+ VpnPortipToPort vpnTargetIpToPort =
+ getNeutronPortFromVpnPortFixedIp(macEntry.getVpnName(), gatewayIp.stringValue());
if (vpnTargetIpToPort != null && vpnTargetIpToPort.isSubnetIp()) {
gatewayMac = Optional.of(vpnTargetIpToPort.getMacAddress());
} else {
return gatewayMac;
}
- void setupGwMacIfExternalVpn(BigInteger dpnId, String interfaceName, long vpnId, WriteTransaction writeInvTxn,
- int addOrRemove, String gwMac) {
+ void setupGwMacIfExternalVpn(BigInteger dpnId, String interfaceName, long 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(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 {}",
}
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);
+ mdsalManager.removeFlow(writeInvTxn, flowEntity);
}
}
}
final Optional<Subnet> subnet = read(LogicalDatastoreType.CONFIGURATION, subnetidentifier);
if (subnet.isPresent()) {
Class<? extends IpVersionBase> ipVersionBase = subnet.get().getIpVersion();
- if (ipVersionBase.equals(IpVersionV4.class)) {
+ if (IpVersionV4.class.equals(ipVersionBase)) {
Subnetmap subnetmap = getSubnetmapFromItsUuid(subnetUuid);
if (subnetmap != null && subnetmap.getRouterInterfaceFixedIp() != null) {
LOG.trace("getVpnSubnetGatewayIp: Obtained subnetMap {} for vpn interface",
return gwIpAddress;
}
+ @Nullable
RouterToNaptSwitch getRouterToNaptSwitch(String routerName) {
InstanceIdentifier<RouterToNaptSwitch> id = InstanceIdentifier.builder(NaptSwitches.class)
.child(RouterToNaptSwitch.class, new RouterToNaptSwitchKey(routerName)).build();
}
+ @Nullable
BigInteger getPrimarySwitchForRouter(String routerName) {
RouterToNaptSwitch routerToNaptSwitch = getRouterToNaptSwitch(routerName);
return routerToNaptSwitch != null ? routerToNaptSwitch.getPrimarySwitchId() : null;
.augmentation(Adjacencies.class).child(Adjacency.class, new AdjacencyKey(ipAddress)).build();
}
+ static InstanceIdentifier<Adjacency> getVpnInterfaceOpDataEntryAdjacencyIdentifier(String intfName, String vpnName,
+ String 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());
return isVxLan ? VrfEntryBase.EncapType.Vxlan : VrfEntryBase.EncapType.Mplsgre;
}
+ @Nullable
org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets.Subnets
getExternalSubnet(Uuid subnetId) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.subnets
return optionalSubnets.isPresent() ? optionalSubnets.get() : null;
}
- Uuid getSubnetFromExternalRouterByIp(Uuid routerId, String ip) {
+ @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();
}
}
}
@SuppressWarnings("checkstyle:linelength")
+ @Nullable
Network getNeutronNetwork(Uuid networkId) {
- Network network = null;
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(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 BigInteger 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;
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) {
* @param subnetUuid the subnet's Uuid
* @return the Subnetmap of Uuid or null if it is not found
*/
- Subnetmap getSubnetmapFromItsUuid(Uuid subnetUuid) {
- Subnetmap sn = null;
+ @Nullable
+ public Subnetmap getSubnetmapFromItsUuid(Uuid subnetUuid) {
InstanceIdentifier<Subnetmap> id = buildSubnetmapIdentifier(subnetUuid);
- Optional<Subnetmap> optionalSn = read(LogicalDatastoreType.CONFIGURATION, id);
- if (optionalSn.isPresent()) {
- sn = optionalSn.get();
- }
- return sn;
+ return read(LogicalDatastoreType.CONFIGURATION, id).orNull();
}
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 = getSubnetmapFromItsUuid(adjacency.getSubnetId());
- if (sn != null && sn.getInternetVpnId() != null) {
- adjacencyEligible = false;
}
return adjacencyEligible;
}
return adjacencyEligible;
}
+ @Nullable
String getInternetVpnFromVpnInstanceList(List<VpnInstanceNames> vpnInstanceList) {
for (VpnInstanceNames vpnInstance : vpnInstanceList) {
String vpnName = vpnInstance.getVpnName();
* @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;
}
ListenableFuture<Void> unsetScheduledToRemoveForVpnInterface(String interfaceName) {
VpnInterfaceBuilder builder = new VpnInterfaceBuilder().withKey(new VpnInterfaceKey(interfaceName));
- return txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.OPERATIONAL, tx -> tx.merge(
+ return txRunner.callWithNewWriteOnlyTransactionAndSubmit(OPERATIONAL, tx -> tx.merge(
VpnUtil.getVpnInterfaceIdentifier(interfaceName), builder.build(),
WriteTransaction.CREATE_MISSING_PARENTS));
}
Optional<ElanDpnInterfacesList> dpnInElanInterfaces = read(LogicalDatastoreType.OPERATIONAL,
elanDpnInterfaceId);
if (dpnInElanInterfaces.isPresent()) {
- List<DpnInterfaces> dpnInterfaces = dpnInElanInterfaces.get().getDpnInterfaces();
+ List<DpnInterfaces> dpnInterfaces =
+ requireNonNullElse(dpnInElanInterfaces.get().getDpnInterfaces(), emptyList());
for (DpnInterfaces dpnInterface : dpnInterfaces) {
dpnIdSet.add(dpnInterface.getDpId());
}
}
+ @Nullable
ElanInterface getElanInterfaceByElanInterfaceName(String elanInterfaceName) {
InstanceIdentifier<ElanInterface> elanInterfaceId = getElanInterfaceConfigurationDataPathId(elanInterfaceName);
return read(LogicalDatastoreType.CONFIGURATION, elanInterfaceId).orNull();
.child(ElanInterface.class, new ElanInterfaceKey(interfaceName)).build();
}
+ @Nullable
DpnInterfaces getElanInterfaceInfoByElanDpn(String elanInstanceName, BigInteger dpId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfacesId = getElanDpnInterfaceOperationalDataPath(elanInstanceName,
dpId);
return read(LogicalDatastoreType.OPERATIONAL, elanDpnInterfacesId).orNull();
}
+ @Nullable
String getExternalElanInterface(String elanInstanceName, BigInteger dpnId) {
DpnInterfaces dpnInterfaces = getElanInterfaceInfoByElanDpn(elanInstanceName, dpnId);
if (dpnInterfaces == null || dpnInterfaces.getInterfaces() == null) {
return isVlan(elanInstance);
}
+ @Nullable
ElanInstance getElanInstanceByName(String elanInstanceName) {
InstanceIdentifier<ElanInstance> elanIdentifierId =
ElanHelper.getElanInstanceConfigurationDataPath(elanInstanceName);
return read(LogicalDatastoreType.CONFIGURATION, elanIdentifierId).orNull();
}
+ @Nullable
String getVpnNameFromElanIntanceName(String elanInstanceName) {
Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
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;
}
+ @Nullable
String getRouterPordIdFromElanInstance(String elanInstanceName) {
Optional<Subnetmaps> subnetMapsData = read(LogicalDatastoreType.CONFIGURATION, buildSubnetMapsWildCardPath());
if (subnetMapsData.isPresent()) {
return null;
}
- boolean shouldPopulateFibForVlan(String vpnName, String elanInstanceName, BigInteger dpnId) {
+ boolean shouldPopulateFibForVlan(String vpnName, @Nullable String elanInstanceName, BigInteger dpnId) {
Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
boolean shouldPopulateFibForVlan = false;
if (!elanInstanceRouterPortMap.isEmpty()) {
return false;
}
- void removePrefixToInterfaceAdj(Adjacency adj, long vpnId, VpnInterfaceOpDataEntry vpnInterfaceOpDataEntry,
- WriteTransaction writeOperTxn) {
- if (writeOperTxn == null) {
- ListenableFutures.addErrorLogging(
- txRunner.callWithNewWriteOnlyTransactionAndSubmit(tx ->
- removePrefixToInterfaceAdj(adj, vpnId, vpnInterfaceOpDataEntry, tx)), LOG,
- "Error removing prefix");
- return;
- }
-
- Optional<Prefixes> prefix = read(LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnId, VpnUtil.getIpPrefix(adj.getIpAddress())));
- List<Prefixes> prefixToInterface = new ArrayList<>();
- List<Prefixes> prefixToInterfaceLocal = new ArrayList<>();
- if (prefix.isPresent()) {
- prefixToInterfaceLocal.add(prefix.get());
- }
- if (prefixToInterfaceLocal.isEmpty()) {
- for (String nh : adj.getNextHopIpList()) {
- prefix = read(LogicalDatastoreType.OPERATIONAL, VpnUtil.getPrefixToInterfaceIdentifier(vpnId,
- VpnUtil.getIpPrefix(nh)));
- if (prefix.isPresent()) {
- prefixToInterfaceLocal.add(prefix.get());
- }
- }
- }
- if (!prefixToInterfaceLocal.isEmpty()) {
- prefixToInterface.addAll(prefixToInterfaceLocal);
- }
- for (Prefixes pref : prefixToInterface) {
- if (VpnUtil.isMatchedPrefixToInterface(pref, vpnInterfaceOpDataEntry)) {
- writeOperTxn.delete(LogicalDatastoreType.OPERATIONAL,
- VpnUtil.getPrefixToInterfaceIdentifier(vpnId, pref.getIpAddress()));
- }
- }
- }
-
public static void sendNeighborSolicationToOfGroup(Ipv6NdUtilService ipv6NdUtilService, Ipv6Address srcIpv6Address,
MacAddress srcMac, Ipv6Address dstIpv6Address, Long ofGroupId, BigInteger dpId) {
SendNeighborSolicitationToOfGroupInput input = new SendNeighborSolicitationToOfGroupInputBuilder()
Also the Subnet overlap in a VPN detection logic to be addressed for router-based-l3vpns.
*/
static boolean areSubnetsOverlapping(String cidr1, String cidr2) {
- String[] ipaddressValues1 = cidr1.split("/");
- int address1 = InetAddresses.coerceToInteger(InetAddresses.forString(ipaddressValues1[0]));
- int cidrPart1 = Integer.parseInt(ipaddressValues1[1]);
- String[] ipaddressValues2 = cidr2.split("/");
- int address2 = InetAddresses.coerceToInteger(InetAddresses.forString(ipaddressValues2[0]));
- int cidrPart2 = Integer.parseInt(ipaddressValues2[1]);
- int comparedValue = 0;
+ 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;
- if (cidrPart1 <= cidrPart2) {
- for (int j = 0; j < cidrPart1; ++j) {
- netmask |= (1 << 31 - j);
- }
- int prefix = address2 & netmask;
- comparedValue = address1 ^ prefix;
- } else {
- for (int j = 0; j < cidrPart2; ++j) {
- netmask |= (1 << 31 - j);
- }
- int prefix = address1 & netmask;
- comparedValue = address2 ^ prefix;
+ for (int j = 0; j < cidrPart; ++j) {
+ netmask |= 1 << 31 - j;
}
- if (comparedValue == 0) {
- return true;
- } else {
- return false;
+ 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 requireNonNullElse(vpnInter.getVpnInstanceNames(), Collections.<VpnInstanceNames>emptyList()).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);
+ }));
+ });
+ }
+
+ // Use Objects.requireNonNullElse instead with JDK9+
+ @Nonnull
+ public static <T> T requireNonNullElse(@Nullable T obj, @Nonnull T defaultObj) {
+ return obj != null ? obj : requireNonNull(defaultObj);
+ }
+
+ public static boolean isDualRouterVpnUpdate(List<String> oldVpnListCopy, List<String> newVpnListCopy) {
+ return oldVpnListCopy.size() == 2 && newVpnListCopy.size() == 3
+ || oldVpnListCopy.size() == 3 && newVpnListCopy.size() == 2;
}
}