import com.google.common.util.concurrent.FutureCallback;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.util.List;
-import java.util.Optional;
import java.util.concurrent.TimeUnit;
import javax.inject.Inject;
import javax.inject.Singleton;
import org.opendaylight.netvirt.fibmanager.api.IFibManager;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.api.IVpnManager;
-import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
-import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.RouterInterface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.vrfentries.VrfEntry;
private final VrfEntryListener vrfEntryListener;
private IVpnManager vpnmanager;
private final FibUtil fibUtil;
- private final InterVpnLinkCache interVpnLinkCache;
@Inject
public FibManagerImpl(final NexthopManager nexthopManager,
final VrfEntryListener vrfEntryListener,
final BundleContext bundleContext,
- final FibUtil fibUtil,
- final InterVpnLinkCache interVpnLinkCache) {
+ final FibUtil fibUtil) {
this.nexthopManager = nexthopManager;
this.vrfEntryListener = vrfEntryListener;
this.fibUtil = fibUtil;
- this.interVpnLinkCache = interVpnLinkCache;
GlobalEventExecutor.INSTANCE.execute(() -> {
ServiceTracker<IVpnManager, ?> tracker = null;
public void removeInterVPNLinkRouteFlows(final String interVpnLinkName,
final boolean isVpnFirstEndPoint,
final VrfEntry vrfEntry) {
- Optional<InterVpnLinkDataComposite> optInterVpnLink = interVpnLinkCache.getInterVpnLinkByName(interVpnLinkName);
- if (!optInterVpnLink.isPresent()) {
- LOG.warn("Could not find InterVpnLink with name {}. InterVpnLink route flows wont be removed",
- interVpnLinkName);
- return;
- }
- InterVpnLinkDataComposite interVpnLink = optInterVpnLink.get();
- String vpnName = isVpnFirstEndPoint ? interVpnLink.getFirstEndpointVpnUuid().get()
- : interVpnLink.getSecondEndpointVpnUuid().get();
-
- vrfEntryListener.removeInterVPNLinkRouteFlows(interVpnLink, vpnName, vrfEntry);
+ //No Op
}
@Override
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
-import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.opendaylight.genius.mdsalutil.matches.MatchMplsLabel;
import org.opendaylight.genius.mdsalutil.matches.MatchTunnelId;
import org.opendaylight.genius.utils.JvmGlobalLocks;
-import org.opendaylight.genius.utils.ServiceIndex;
import org.opendaylight.genius.utils.batching.SubTransaction;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.infrautils.utils.concurrent.Executors;
import org.opendaylight.netvirt.fibmanager.api.RouteOrigin;
import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
import org.opendaylight.netvirt.vpnmanager.api.VpnHelper;
-import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache;
-import org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkDataComposite;
import org.opendaylight.serviceutils.tools.listener.AbstractAsyncDataTreeChangeListener;
import org.opendaylight.serviceutils.upgrade.UpgradeState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.Instruction;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.list.InstructionKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.fibmanager.rev150330.FibEntries;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
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.AdjacencyBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.netvirt.inter.vpn.link.rev160311.inter.vpn.link.states.InterVpnLinkState.State;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
import org.opendaylight.yangtools.yang.common.Uint32;
private final JobCoordinator jobCoordinator;
private final IElanService elanManager;
private final FibUtil fibUtil;
- private final InterVpnLinkCache interVpnLinkCache;
private final List<AutoCloseable> closeables = new CopyOnWriteArrayList<>();
private final UpgradeState upgradeState;
private final DataTreeEventCallbackRegistrar eventCallbacks;
final RouterInterfaceVrfEntryHandler routerInterfaceVrfEntryHandler,
final JobCoordinator jobCoordinator,
final FibUtil fibUtil,
- final InterVpnLinkCache interVpnLinkCache,
final UpgradeState upgradeState,
final DataTreeEventCallbackRegistrar eventCallbacks) {
super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(FibEntries.class)
this.routerInterfaceVrfEntryHandler = routerInterfaceVrfEntryHandler;
this.jobCoordinator = jobCoordinator;
this.fibUtil = fibUtil;
- this.interVpnLinkCache = interVpnLinkCache;
this.upgradeState = upgradeState;
this.eventCallbacks = eventCallbacks;
}
final String rd = identifier.firstKeyOf(VrfTables.class).getRouteDistinguisher();
LOG.debug("UPDATE: Updating Fib Entries to rd {} prefix {} route-paths {} origin {} old-origin {}", rd,
update.getDestPrefix(), update.getRoutePaths(), update.getOrigin(), original.getOrigin());
+
+ //Ignore any Fib Entry changes for subneroute
+ if (RouteOrigin.value(update.getOrigin()) == RouteOrigin.CONNECTED) {
+ LOG.info("UPDATE: Updated Connected Fib Entries with rd {} prefix {} old-nexthop {} "
+ + "new-nexthop {} origin {}",
+ rd, update.getDestPrefix(), original.getRoutePaths(), update.getRoutePaths(),
+ update.getOrigin());
+ return;
+ }
+
// Handle BGP Routes first
if (RouteOrigin.value(update.getOrigin()) == RouteOrigin.BGP) {
bgpRouteVrfEntryHandler.updateFlows(identifier, original, update, rd);
}
})), MAX_RETRIES);
}
-
- Optional<String> optVpnUuid = fibUtil.getVpnNameFromRd(rd);
- if (optVpnUuid.isPresent()) {
- String vpnUuid = optVpnUuid.get();
- InterVpnLinkDataComposite interVpnLink = interVpnLinkCache.getInterVpnLinkByVpnId(vpnUuid).orElse(null);
- if (interVpnLink != null) {
- LOG.debug("InterVpnLink {} found in Cache linking Vpn {}", interVpnLink.getInterVpnLinkName(), vpnUuid);
- FibUtil.getFirstNextHopAddress(vrfEntry).ifPresent(routeNexthop -> {
- if (interVpnLink.isIpAddrTheOtherVpnEndpoint(routeNexthop, vpnUuid)) {
- // This is an static route that points to the other endpoint of an InterVpnLink
- // In that case, we should add another entry in FIB table pointing to LPortDispatcher table.
- installIVpnLinkSwitchingFlows(interVpnLink, vpnUuid, vrfEntry, vpnId);
- installInterVpnRouteInLFib(interVpnLink, vpnUuid, vrfEntry, etherType);
- }
- });
- }
- }
}
void refreshFibTables(String rd, String prefix) {
LOG.error("Unable to get etherType for IP Prefix {}", vrfEntry.getDestPrefix());
return;
}
- FibUtil.getLabelFromRoutePaths(vrfEntry).ifPresent(label -> {
- List<String> nextHopAddressList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
- final LabelRouteInfoKey lriKey = new LabelRouteInfoKey(label);
- final ReentrantLock lock = lockFor(lriKey);
- lock.lock();
- try {
- LabelRouteInfo lri = getLabelRouteInfo(lriKey);
- if (isPrefixAndNextHopPresentInLri(vrfEntry.getDestPrefix(), nextHopAddressList, lri)) {
-
- if (RouteOrigin.value(vrfEntry.getOrigin()) == RouteOrigin.SELF_IMPORTED) {
- Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional =
- fibUtil.getVpnInstanceOpData(rd);
- if (vpnInstanceOpDataEntryOptional.isPresent()) {
- String vpnInstanceName = vpnInstanceOpDataEntryOptional.get().getVpnInstanceName();
- if (!lri.getVpnInstanceList().contains(vpnInstanceName)) {
- updateVpnReferencesInLri(lri, vpnInstanceName, false);
- }
- }
- }
- LOG.debug("SUBNETROUTE: installSubnetRouteInFib: Fetched labelRouteInfo for label {} interface {}"
- + " and got dpn {}", label, lri.getVpnInterfaceName(), lri.getDpnId());
- }
- } finally {
- lock.unlock();
- }
- });
final List<InstructionInfo> instructions = new ArrayList<>();
Uint64 subnetRouteMeta = Uint64.valueOf(BigInteger.valueOf(elanTag).shiftLeft(24)
.or(BigInteger.valueOf(vpnId.longValue()).shiftLeft(1)));
}
}
- /*
- * For a given route, it installs a flow in LFIB that sets the lportTag of the other endpoint and sends to
- * LportDispatcher table (via table 80)
- */
- private void installInterVpnRouteInLFib(final InterVpnLinkDataComposite interVpnLink, final String vpnName,
- final VrfEntry vrfEntry, int etherType) {
- // INTERVPN routes are routes in a Vpn1 that have been leaked to Vpn2. In DC-GW, this Vpn2 route is pointing
- // to a list of DPNs where Vpn2's VpnLink was instantiated. In these DPNs LFIB must be programmed so that the
- // packet is commuted from Vpn2 to Vpn1.
- String interVpnLinkName = interVpnLink.getInterVpnLinkName();
- if (!interVpnLink.isActive()) {
- LOG.warn("InterVpnLink {} is NOT ACTIVE. InterVpnLink flows for prefix={} wont be installed in LFIB",
- interVpnLinkName, vrfEntry.getDestPrefix());
- return;
- }
-
- Optional<Uint32> optLportTag = interVpnLink.getEndpointLportTagByVpnName(vpnName);
- if (!optLportTag.isPresent()) {
- LOG.warn("Could not retrieve lportTag for VPN {} endpoint in InterVpnLink {}", vpnName, interVpnLinkName);
- return;
- }
-
- Long lportTag = optLportTag.get().toJava();
- Uint32 label = FibUtil.getLabelFromRoutePaths(vrfEntry).orElse(null);
- if (label == null) {
- LOG.error("Could not find label in vrfEntry=[prefix={} routePaths={}]. LFIB entry for InterVpnLink skipped",
- vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths());
- return;
- }
- List<ActionInfo> actionsInfos = Collections.singletonList(new ActionPopMpls(etherType));
- List<InstructionInfo> instructions = Arrays.asList(
- new InstructionApplyActions(actionsInfos),
- new InstructionWriteMetadata(MetaDataUtil.getMetaDataForLPortDispatcher(lportTag.intValue(),
- ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
- NwConstants.L3VPN_SERVICE_INDEX)),
- MetaDataUtil.getMetaDataMaskForLPortDispatcher()),
- new InstructionGotoTable(NwConstants.L3_INTERFACE_TABLE));
- List<String> interVpnNextHopList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
- List<Uint64> targetDpns = interVpnLink.getEndpointDpnsByVpnName(vpnName);
-
- for (Uint64 dpId : targetDpns) {
- LOG.debug("Installing flow: VrfEntry=[prefix={} label={} nexthop={}] dpn {} for InterVpnLink {} in LFIB",
- vrfEntry.getDestPrefix(), label, interVpnNextHopList, dpId, interVpnLink.getInterVpnLinkName());
-
- makeLFibTableEntry(dpId, label, instructions, LFIB_INTERVPN_PRIORITY, NwConstants.ADD_FLOW,
- /*writeTx*/null);
- }
- }
-
-
- /*
- * Installs the flows in FIB table that, for a given route, do the switching from one VPN to the other.
- */
- private void installIVpnLinkSwitchingFlows(final InterVpnLinkDataComposite interVpnLink, final String vpnUuid,
- final VrfEntry vrfEntry, Uint32 vpnTag) {
- Preconditions.checkNotNull(interVpnLink, "InterVpnLink cannot be null");
- Preconditions.checkArgument(vrfEntry.getRoutePaths() != null
- && vrfEntry.getRoutePaths().size() == 1);
- String destination = vrfEntry.getDestPrefix();
- String nextHop = new ArrayList<RoutePaths>(vrfEntry.getRoutePaths().values()).get(0).getNexthopAddress();
- String interVpnLinkName = interVpnLink.getInterVpnLinkName();
-
- // After having received a static route, we should check if the vpn is part of an inter-vpn-link.
- // In that case, we should populate the FIB table of the VPN pointing to LPortDisptacher table
- // using as metadata the LPortTag associated to that vpn in the inter-vpn-link.
- if (interVpnLink.getState().orElse(State.Error) != State.Active) {
- LOG.warn("Route to {} with nexthop={} cannot be installed because the interVpnLink {} is not active",
- destination, nextHop, interVpnLinkName);
- return;
- }
-
- Optional<Uint32> optOtherEndpointLportTag = interVpnLink.getOtherEndpointLportTagByVpnName(vpnUuid);
- if (!optOtherEndpointLportTag.isPresent()) {
- LOG.warn("Could not find suitable LportTag for the endpoint opposite to vpn {} in interVpnLink {}",
- vpnUuid, interVpnLinkName);
- return;
- }
-
- List<Uint64> targetDpns = interVpnLink.getEndpointDpnsByVpnName(vpnUuid);
- if (targetDpns.isEmpty()) {
- LOG.warn("Could not find DPNs for endpoint opposite to vpn {} in interVpnLink {}",
- vpnUuid, interVpnLinkName);
- return;
- }
-
- String[] values = destination.split("/");
- String destPrefixIpAddress = values[0];
- int prefixLength = values.length == 1 ? 0 : Integer.parseInt(values[1]);
-
- List<MatchInfo> matches = new ArrayList<>();
- matches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnTag.longValue()),
- MetaDataUtil.METADATA_MASK_VRFID));
- matches.add(MatchEthernetType.IPV4);
-
- if (prefixLength != 0) {
- matches.add(new MatchIpv4Destination(destPrefixIpAddress, Integer.toString(prefixLength)));
- }
-
- List<Instruction> instructions =
- Arrays.asList(new InstructionWriteMetadata(
- MetaDataUtil.getMetaDataForLPortDispatcher(optOtherEndpointLportTag.get().intValue(),
- ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME, NwConstants
- .L3VPN_SERVICE_INDEX)),
- MetaDataUtil.getMetaDataMaskForLPortDispatcher()).buildInstruction(0),
- new InstructionGotoTable(NwConstants.L3_INTERFACE_TABLE).buildInstruction(1));
- Map<InstructionKey, Instruction> instructionsMap = new HashMap<InstructionKey, Instruction>();
- int instructionKey = 0;
- for (Instruction instructionObj : instructions) {
- instructionsMap.put(new InstructionKey(++instructionKey), instructionObj);
- }
-
- int priority = DEFAULT_FIB_FLOW_PRIORITY + prefixLength;
- String flowRef = getInterVpnFibFlowRef(interVpnLinkName, destination, nextHop);
- Flow flowEntity = MDSALUtil.buildFlowNew(NwConstants.L3_FIB_TABLE, flowRef, priority, flowRef, 0, 0,
- COOKIE_VM_FIB_TABLE, matches, instructionsMap);
-
- LOG.trace("Installing flow in FIB table for vpn {} interVpnLink {} nextHop {} key {}",
- vpnUuid, interVpnLink.getInterVpnLinkName(), nextHop, flowRef);
-
- for (Uint64 dpId : targetDpns) {
-
- LOG.debug("Installing flow: VrfEntry=[prefix={} route-paths={}] dpn {} for InterVpnLink {} in FIB",
- vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths(),
- dpId, interVpnLink.getInterVpnLinkName());
-
- mdsalManager.installFlow(dpId, flowEntity);
- }
- }
-
private List<Uint64> createLocalFibEntry(Uint32 vpnId, String rd, VrfEntry vrfEntry, int etherType) {
List<Uint64> returnLocalDpnId = new ArrayList<>();
String localNextHopIP = vrfEntry.getDestPrefix();
return null;
}
+ @SuppressFBWarnings
private boolean deleteLabelRouteInfo(LabelRouteInfo lri, String vpnInstanceName,
@Nullable TypedWriteTransaction<Operational> tx) {
if (lri == null) {
return true;
}
-
LOG.debug("deleting LRI : for label {} vpninstancename {}", lri.getLabel(), vpnInstanceName);
InstanceIdentifier<LabelRouteInfo> lriId = InstanceIdentifier.builder(LabelRouteMap.class)
.child(LabelRouteInfo.class, new LabelRouteInfoKey(lri.getLabel())).build();
SubnetRoute subnetRoute = vrfEntry.augmentation(SubnetRoute.class);
final java.util.Optional<Uint32> optionalLabel = FibUtil.getLabelFromRoutePaths(vrfEntry);
- List<String> nextHopAddressList = FibHelper.getNextHopListFromRoutePaths(vrfEntry);
String vpnName = fibUtil.getVpnNameFromId(vpnInstance.getVpnId());
if (subnetRoute != null) {
long elanTag = subnetRoute.getElantag().toJava();
}
})));
}
- optionalLabel.ifPresent(label -> {
- final LabelRouteInfoKey lriKey = new LabelRouteInfoKey(label);
- final ReentrantLock lock = lockFor(lriKey);
- lock.lock();
- try {
- LabelRouteInfo lri = getLabelRouteInfo(lriKey);
- if (isPrefixAndNextHopPresentInLri(vrfEntry.getDestPrefix(), nextHopAddressList, lri)) {
- Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional =
- fibUtil.getVpnInstanceOpData(rd);
- String vpnInstanceName = "";
- if (vpnInstanceOpDataEntryOptional.isPresent()) {
- vpnInstanceName = vpnInstanceOpDataEntryOptional.get().getVpnInstanceName();
- }
- boolean lriRemoved = this.deleteLabelRouteInfo(lri, vpnInstanceName, null);
- if (lriRemoved) {
- String parentRd = lri.getParentVpnRd();
- fibUtil.releaseId(FibConstants.VPN_IDPOOL_NAME, FibUtil.getNextHopLabelKey(
- parentRd, vrfEntry.getDestPrefix()));
- LOG.trace("SUBNETROUTE: deleteFibEntries: Released subnetroute label {} for rd {} prefix {}"
- + " as labelRouteInfo cleared", label, rd, vrfEntry.getDestPrefix());
- }
- } else {
- fibUtil.releaseId(FibConstants.VPN_IDPOOL_NAME, FibUtil.getNextHopLabelKey(
- rd, vrfEntry.getDestPrefix()));
- LOG.trace("SUBNETROUTE: deleteFibEntries: Released subnetroute label {} for rd {} prefix {}",
- label, rd, vrfEntry.getDestPrefix());
- }
- } finally {
- lock.unlock();
- }
- });
return;
}
//DS entries in VPN Op DS, VpnInstanceOpData and PrefixToInterface to complete deletion
cleanUpOpDataForFib(vpnInstance.getVpnId(), vrfTableKey.getRouteDistinguisher(), vrfEntry);
- // Remove all fib entries configured due to interVpnLink, when nexthop is the opposite endPoint
- // of the interVpnLink.
- Optional<String> optVpnUuid = fibUtil.getVpnNameFromRd(rd);
- if (optVpnUuid.isPresent()) {
- String vpnUuid = optVpnUuid.get();
- FibUtil.getFirstNextHopAddress(vrfEntry).ifPresent(routeNexthop -> {
- Optional<InterVpnLinkDataComposite> optInterVpnLink = interVpnLinkCache.getInterVpnLinkByVpnId(vpnUuid);
- if (optInterVpnLink.isPresent()) {
- InterVpnLinkDataComposite interVpnLink = optInterVpnLink.get();
- if (interVpnLink.isIpAddrTheOtherVpnEndpoint(routeNexthop, vpnUuid)) {
- // This is route that points to the other endpoint of an InterVpnLink
- // In that case, we should look for the FIB table pointing to
- // LPortDispatcher table and remove it.
- removeInterVPNLinkRouteFlows(interVpnLink, vpnUuid, vrfEntry);
- }
- }
- });
- }
-
}
private void makeLFibTableEntry(Uint64 dpId, Uint32 label, @Nullable List<InstructionInfo> instructions,
return idBuilder.build();
}
- private String getInterVpnFibFlowRef(String interVpnLinkName, String prefix, String nextHop) {
- return FLOWID_PREFIX + interVpnLinkName + NwConstants.FLOWID_SEPARATOR + prefix + NwConstants
- .FLOWID_SEPARATOR + nextHop;
- }
-
private String getTableMissFlowRef(Uint64 dpnId, short tableId, Uint32 tableMiss) {
return FLOWID_PREFIX + dpnId + NwConstants.FLOWID_SEPARATOR + tableId + NwConstants.FLOWID_SEPARATOR
+ tableMiss + FLOWID_PREFIX;
return null;
}
- public void removeInterVPNLinkRouteFlows(final InterVpnLinkDataComposite interVpnLink,
- final String vpnName,
- final VrfEntry vrfEntry) {
- Preconditions.checkArgument(vrfEntry.getRoutePaths() != null && vrfEntry.getRoutePaths().size() == 1);
-
- String interVpnLinkName = interVpnLink.getInterVpnLinkName();
- List<Uint64> targetDpns = interVpnLink.getEndpointDpnsByVpnName(vpnName);
-
- if (targetDpns.isEmpty()) {
- LOG.warn("Could not find DPNs for VPN {} in InterVpnLink {}", vpnName, interVpnLinkName);
- return;
- }
-
- java.util.Optional<String> optNextHop = FibUtil.getFirstNextHopAddress(vrfEntry);
- java.util.Optional<Uint32> optLabel = FibUtil.getLabelFromRoutePaths(vrfEntry);
-
- // delete from FIB
- //
- optNextHop.ifPresent(nextHop -> {
- String flowRef = getInterVpnFibFlowRef(interVpnLinkName, vrfEntry.getDestPrefix(), nextHop);
- FlowKey flowKey = new FlowKey(new FlowId(flowRef));
- Flow flow = new FlowBuilder().withKey(flowKey).setId(new FlowId(flowRef))
- .setTableId(NwConstants.L3_FIB_TABLE).setFlowName(flowRef).build();
-
- LOG.trace("Removing flow in FIB table for interVpnLink {} key {}", interVpnLinkName, flowRef);
- for (Uint64 dpId : targetDpns) {
- LOG.debug("Removing flow: VrfEntry=[prefix={} nexthop={}] dpn {} for InterVpnLink {} in FIB",
- vrfEntry.getDestPrefix(), nextHop, dpId, interVpnLinkName);
-
- mdsalManager.removeFlow(dpId, flow);
- }
- });
-
- // delete from LFIB
- //
- optLabel.ifPresent(label -> {
- LOG.trace("Removing flow in FIB table for interVpnLink {}", interVpnLinkName);
-
- LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION, tx -> {
- for (Uint64 dpId : targetDpns) {
- LOG.debug("Removing flow: VrfEntry=[prefix={} label={}] dpn {} for InterVpnLink {} in LFIB",
- vrfEntry.getDestPrefix(), label, dpId, interVpnLinkName);
- makeLFibTableEntry(dpId, label, /*instructions*/null, LFIB_INTERVPN_PRIORITY,
- NwConstants.DEL_FLOW, tx);
- }
- }), LOG, "Error removing flows");
- });
- }
-
private static boolean isPrefixAndNextHopPresentInLri(String prefix,
List<String> nextHopAddressList, LabelRouteInfo lri) {
return lri != null && Objects.equals(lri.getPrefix(), prefix)
availability="optional"/>
<reference id="jobCoordinator"
interface="org.opendaylight.infrautils.jobcoordinator.JobCoordinator"/>
- <reference id="interVpnLinkCache"
- interface="org.opendaylight.netvirt.vpnmanager.api.intervpnlink.InterVpnLinkCache"
- availability="optional"/>
<reference id="iInterfaceManager"
interface="org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager" />
<reference id="iITMProvider"
int DEFAULT_LPORT_DISPATCHER_FLOW_PRIORITY = 1;
int VPN_ID_LENGTH = 24;
Uint32 INVALID_ID = Uint32.ZERO;
+ int INVALID_IDMAN_ID = 0;
String SEPARATOR = ".";
Uint64 COOKIE_L3_BASE = Uint64.valueOf("8000000", 16).intern();
String FLOWID_PREFIX = "L3.";
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
public void update(InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
- VpnInstanceOpDataEntry original, VpnInstanceOpDataEntry update) {
+ VpnInstanceOpDataEntry original, VpnInstanceOpDataEntry update) {
LOG.info("update: Processing update for vpn {} with rd {}", update.getVpnInstanceName(), update.getVrfId());
if (update.getVpnState() == VpnInstanceOpDataEntry.VpnState.PendingDelete
&& vpnFootprintService.isVpnFootPrintCleared(update)) {
// Two transactions are used, one for operational, one for config; we only submit the config
// transaction if the operational transaction succeeds
ListenableFuture<?> operationalFuture = txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- Datastore.OPERATIONAL, operTx -> {
- // Clean up VPNExtraRoutes Operational DS
+ Datastore.OPERATIONAL, operTx -> {
+ // Clean up VPNExtraRoutes Operational DS
if (rds != null && VpnUtil.isBgpVpn(vpnName, primaryRd)) {
if (update.getType() == VpnInstanceOpDataEntry.Type.L2) {
rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(
- rd, false, AddressFamily.L2VPN));
+ rd, false, AddressFamily.L2VPN));
}
if (update.getIpAddressFamilyConfigured()
- == VpnInstanceOpDataEntry.IpAddressFamilyConfigured.Ipv4) {
+ == VpnInstanceOpDataEntry.IpAddressFamilyConfigured.Ipv4) {
rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(
- rd, false, AddressFamily.IPV4));
+ rd, false, AddressFamily.IPV4));
}
if (update.getIpAddressFamilyConfigured()
- == VpnInstanceOpDataEntry.IpAddressFamilyConfigured.Ipv6) {
+ == VpnInstanceOpDataEntry.IpAddressFamilyConfigured.Ipv6) {
rds.parallelStream().forEach(rd -> bgpManager.deleteVrf(
- rd, false, AddressFamily.IPV6));
+ rd, false, AddressFamily.IPV6));
}
if (update.getIpAddressFamilyConfigured()
- == VpnInstanceOpDataEntry.IpAddressFamilyConfigured.Ipv4AndIpv6) {
+ == VpnInstanceOpDataEntry.IpAddressFamilyConfigured.Ipv4AndIpv6) {
rds.parallelStream()
- .forEach(rd -> bgpManager.deleteVrf(
- rd, false, AddressFamily.IPV4));
+ .forEach(rd -> bgpManager.deleteVrf(
+ rd, false, AddressFamily.IPV4));
rds.parallelStream()
- .forEach(rd -> bgpManager.deleteVrf(
- rd, false, AddressFamily.IPV6));
+ .forEach(rd -> bgpManager.deleteVrf(
+ rd, false, AddressFamily.IPV6));
}
}
InstanceIdentifier<Vpn> vpnToExtraroute =
Optional<Vpn> optVpnToExtraroute = Optional.empty();
try {
optVpnToExtraroute = SingleTransactionDataBroker.syncReadOptional(dataBroker,
- LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
+ LogicalDatastoreType.OPERATIONAL, vpnToExtraroute);
} catch (InterruptedException | ExecutionException e) {
LOG.error("update: Failed to read VpnToExtraRoute for vpn {}", vpnName);
}
if (VpnUtil.isL3VpnOverVxLan(update.getL3vni())) {
vpnUtil.removeExternalTunnelDemuxFlows(vpnName);
}
- // Clean up PrefixToInterface Operational DS
+ // Clean up PrefixToInterface Operational DS
Optional<VpnIds> optPrefixToIntf = Optional.empty();
try {
optPrefixToIntf = SingleTransactionDataBroker.syncReadOptional(dataBroker,
@Override
public void onSuccess(Object result) {
Futures.addCallback(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- Datastore.CONFIGURATION, confTx -> {
- // Clean up VpnInstanceToVpnId from Config DS
+ Datastore.CONFIGURATION, confTx -> {
+ // Clean up VpnInstanceToVpnId from Config DS
VpnUtil.removeVpnIdToVpnInstance(vpnId, confTx);
VpnUtil.removeVpnInstanceToVpnId(vpnName, confTx);
LOG.trace("Removed vpnIdentifier for rd{} vpnname {}", primaryRd, vpnName);
}
}), new VpnOpStatusListener.PostDeleteVpnInstanceWorker(vpnName),
MoreExecutors.directExecutor());
- // Note: Release the of VpnId will happen in PostDeleteVpnInstancWorker only if
- // operationalTxn/Config succeeds.
+ // Note: Release the of VpnId will happen in PostDeleteVpnInstancWorker only if
+ // operationalTxn/Config succeeds.
}
@Override
}
if (original == null) {
LOG.error("VpnOpStatusListener.update: vpn {} with RD {}. add() handler already called",
- vpnName, primaryRd);
+ vpnName, primaryRd);
return;
}
if (update.getVpnTargets() == null) {
LOG.error("VpnOpStatusListener.update: vpn {} with RD {} vpnTargets not ready",
- vpnName, primaryRd);
+ vpnName, primaryRd);
return;
}
Map<VpnTargetKey, VpnTarget> vpnTargetMap = update.getVpnTargets().getVpnTarget();
}
} else {
LOG.error("VpnOpStatusListener.update: vpn target list is empty, cannot add BGP"
- + " VPN {} RD {}", vpnName, primaryRd);
+ + " VPN {} RD {}", vpnName, primaryRd);
return;
}
jobCoordinator.enqueueJob("VPN-" + update.getVpnInstanceName(), () -> {
try {
List<String> importRTList = rd.equals(primaryRd) ? irtList : emptyList();
LOG.info("VpnOpStatusListener.update: updating BGPVPN for vpn {} with RD {}"
- + " Type is {}, IPtype is {}, iRT {}", vpnName, primaryRd, update.getType(),
+ + " Type is {}, IPtype is {}, iRT {}", vpnName, primaryRd, update.getType(),
update.getIpAddressFamilyConfigured(), importRTList);
int ipValue = VpnUtil.getIpFamilyValueToRemove(original,update);
switch (ipValue) {
}
} catch (RuntimeException e) {
LOG.error("VpnOpStatusListener.update: Exception when updating VRF to BGP for vpn {} rd {}",
- vpnName, rd, e);
+ vpnName, rd, e);
}
});
return emptyList();
@Override
public void add(final InstanceIdentifier<VpnInstanceOpDataEntry> identifier,
- final VpnInstanceOpDataEntry value) {
+ final VpnInstanceOpDataEntry value) {
LOG.debug("add: Ignoring vpn Op {} with rd {}", value.getVpnInstanceName(), value.getVrfId());
}
*/
@Override
public void onSuccess(Object ignored) {
- vpnUtil.releaseId(VpnConstants.VPN_IDPOOL_NAME, vpnName);
+ Integer releaseId = vpnUtil.releaseId(VpnConstants.VPN_IDPOOL_NAME, vpnName);
log.info("onSuccess: VpnId for VpnName {} is released to IdManager successfully.", vpnName);
+ if (releaseId == VpnConstants.INVALID_IDMAN_ID) {
+ LOG.error("VpnOpStatusListener: onSuccess: Failed to release ID for vpn {}, vpn id pool {}", vpnName,
+ VpnConstants.VPN_IDPOOL_NAME);
+ }
}
/**
@Override
public void onFailure(Throwable throwable) {
log.error("onFailure: Job for vpnInstance: {} failed with exception:",
- vpnName , throwable);
+ vpnName , throwable);
}
}
}
package org.opendaylight.netvirt.vpnmanager;
import com.google.common.base.Preconditions;
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.ExternalNetworks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.Networks;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.natservice.rev160111.external.networks.NetworksKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.neutronvpn.rev150602.Subnetmaps;
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.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.opendaylight.yangtools.yang.common.Uint64;
@Inject
public VpnSubnetRouteHandler(final DataBroker dataBroker, final SubnetOpDpnManager subnetOpDpnManager,
- final IBgpManager bgpManager, final VpnOpDataSyncer vpnOpDataSyncer, final VpnNodeListener vpnNodeListener,
- final IFibManager fibManager, VpnUtil vpnUtil) {
+ final IBgpManager bgpManager, final VpnOpDataSyncer vpnOpDataSyncer,
+ final VpnNodeListener vpnNodeListener,
+ final IFibManager fibManager, VpnUtil vpnUtil) {
this.dataBroker = dataBroker;
this.subOpDpnManager = subnetOpDpnManager;
this.bgpManager = bgpManager;
public void onSubnetAddedToVpn(Subnetmap subnetmap, boolean isBgpVpn, Long elanTag) {
Uuid subnetId = subnetmap.getId();
String subnetIp = subnetmap.getSubnetIp();
- Subnetmap subMap = null;
SubnetOpDataEntry subOpEntry = null;
SubnetOpDataEntryBuilder subOpBuilder = null;
InstanceIdentifier<SubnetOpDataEntry> subOpIdentifier = null;
Optional<SubnetOpDataEntry> optionalSubs = null;
+ Uint32 label;
- Preconditions.checkNotNull(subnetId, LOGGING_PREFIX + " onSubnetAddedToVpn: SubnetId cannot be null or empty!");
+ Preconditions.checkNotNull(subnetId,
+ LOGGING_PREFIX + " onSubnetAddedToVpn: SubnetId cannot be null or empty!");
Preconditions.checkNotNull(subnetIp,
LOGGING_PREFIX + " onSubnetAddedToVpn: SubnetPrefix cannot be null or empty!");
- Preconditions.checkNotNull(elanTag, LOGGING_PREFIX + " onSubnetAddedToVpn: ElanTag cannot be null or empty!");
+ Preconditions.checkNotNull(elanTag,
+ LOGGING_PREFIX + " onSubnetAddedToVpn: ElanTag cannot be null or empty!");
if (subnetmap.getVpnId() == null) {
LOG.error("onSubnetAddedToVpn: VpnId {} for subnet {} not found, bailing out", subnetmap.getVpnId(),
//TODO(vivek): Change this to use more granularized lock at subnetId level
try {
vpnUtil.lockSubnet(subnetId.getValue());
- // Please check if subnetId belongs to an External Network
- InstanceIdentifier<Subnetmap> subMapid =
- InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
- new SubnetmapKey(subnetId)).build();
- Optional<Subnetmap> sm = SingleTransactionDataBroker.syncReadOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, subMapid);
- if (!sm.isPresent()) {
- LOG.error("{} onSubnetAddedToVpn: Unable to retrieve subnetmap entry for subnet {} IP {}"
- + " vpnName {}", LOGGING_PREFIX, subnetId, subnetIp, vpnName);
- return;
- }
- subMap = sm.get();
-
if (isBgpVpn) {
InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
- .child(Networks.class, new NetworksKey(subMap.getNetworkId())).build();
+ .child(Networks.class, new NetworksKey(subnetmap.getNetworkId())).build();
Optional<Networks> optionalNets = SingleTransactionDataBroker.syncReadOptional(dataBroker,
LogicalDatastoreType.CONFIGURATION, netsIdentifier);
if (optionalNets.isPresent()) {
LOG.info("{} onSubnetAddedToVpn: subnet {} with IP {} is an external subnet on external "
+ "network {}, so ignoring this for SubnetRoute on vpn {}", LOGGING_PREFIX,
- subnetId.getValue(), subnetIp, subMap.getNetworkId().getValue(), vpnName);
+ subnetId.getValue(), subnetIp, subnetmap.getNetworkId().getValue(), vpnName);
return;
}
}
+ " subnet {} subnetIp {} ", LOGGING_PREFIX, vpnName, subnetId.getValue(), subnetIp);
return;
}
+ //Allocate MPLS label for subnet-route at the time SubnetOpDataEntry creation
+ label = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME,
+ VpnUtil.getNextHopLabelKey(primaryRd, subnetIp));
+ if (label == VpnConstants.INVALID_ID) {
+ LOG.error("onSubnetAddedToVpn: Unable to retrieve label for rd {}, subnetIp {}",
+ primaryRd, subnetIp);
+ return;
+ }
subOpBuilder.setVrfId(primaryRd);
subOpBuilder.setVpnName(vpnName);
subOpBuilder.setSubnetToDpn(new ArrayList<>());
subOpBuilder.setRouteAdvState(TaskState.Idle);
subOpBuilder.setElanTag(elanTag);
+ subOpBuilder.setLabel(label);
Long l3Vni = vpnInstanceOpData.getL3vni() != null ? vpnInstanceOpData.getL3vni().toJava() : 0L;
subOpBuilder.setL3vni(l3Vni);
subOpEntry = subOpBuilder.build();
} catch (TransactionCommitFailedException e) {
LOG.error("{} Creation of SubnetOpDataEntry for subnet {} failed ", LOGGING_PREFIX,
subnetId.getValue(), e);
- // The second part of this method depends on subMap being non-null so fail fast here.
+ // The second part of this method depends on subnetmap being non-null so fail fast here.
return;
} catch (RuntimeException e) { //TODO: Avoid this
LOG.error("{} onSubnetAddedToVpn: Unable to handle subnet {} with ip {} added to vpn {}", LOGGING_PREFIX,
subOpIdentifier);
subOpBuilder = new SubnetOpDataEntryBuilder(optionalSubs.get())
.withKey(new SubnetOpDataEntryKey(subnetId));
- List<Uuid> portList = subMap.getPortList();
+ List<Uuid> portList = subnetmap.getPortList();
if (portList != null) {
for (Uuid port : portList) {
Interface intfState = InterfaceUtils.getInterfaceStateFromOperDS(dataBroker,port.getValue());
} catch (Exception e) {
LOG.error("{} onSubnetAddedToVpn: Unable to obtain dpnId for interface {},"
+ " subnetroute inclusion for this interface for subnet {} subnetIp {} "
- + "vpn {} failed with exception", LOGGING_PREFIX, port.getValue(),
+ + "vpn {} failed with exception", LOGGING_PREFIX, port.getValue(),
subnetId.getValue(), subnetIp, vpnName, e);
continue;
}
}
}
electNewDpnForSubnetRoute(subOpBuilder, null /* oldDpnId */, subnetId,
- subMap.getNetworkId(), isBgpVpn);
+ subnetmap.getNetworkId(), isBgpVpn, label);
subOpEntry = subOpBuilder.build();
SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier,
subOpEntry, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
+ " vpnName {} rd {} TaskState {}", LOGGING_PREFIX, subnetId.getValue(),
optionalSubs.get().getSubnetCidr(), optionalSubs.get().getVpnName(),
optionalSubs.get().getVrfId(), optionalSubs.get().getRouteAdvState());
- /* If subnet is deleted (or if its removed from VPN), the ports that are DOWN on that subnet
- * will continue to be stale in portOpData DS, as subDpnList used for portOpData removal will
- * contain only ports that are UP. So here we explicitly cleanup the ports of the subnet by
- * going through the list of ports on the subnet
- */
- InstanceIdentifier<Subnetmap> subMapid =
- InstanceIdentifier.builder(Subnetmaps.class).child(Subnetmap.class,
- new SubnetmapKey(subnetId)).build();
- Optional<Subnetmap> sm = SingleTransactionDataBroker.syncReadOptional(dataBroker,
- LogicalDatastoreType.CONFIGURATION, subMapid);
- if (!sm.isPresent()) {
- LOG.error("{} onSubnetDeletedFromVpn: Stale ports removal: Unable to retrieve subnetmap entry"
- + " for subnet {} subnetIp {} vpnName {}", LOGGING_PREFIX, subnetId.getValue(),
- optionalSubs.get().getSubnetCidr(), optionalSubs.get().getVpnName());
- } else {
- Subnetmap subMap = sm.get();
- List<Uuid> portList = subMap.getPortList();
- if (portList != null) {
- for (Uuid port : portList) {
- InstanceIdentifier<PortOpDataEntry> portOpIdentifier =
- InstanceIdentifier.builder(PortOpData.class).child(PortOpDataEntry.class,
- new PortOpDataEntryKey(port.getValue())).build();
- LOG.trace("{} onSubnetDeletedFromVpn: Deleting portOpData entry for port {}"
- + " from subnet {} subnetIp {} vpnName {} TaskState {}",
- LOGGING_PREFIX, port.getValue(), subnetId.getValue(),
- optionalSubs.get().getSubnetCidr(), optionalSubs.get().getVpnName(),
- optionalSubs.get().getRouteAdvState());
- SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL,
- portOpIdentifier, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
- }
+ /* If subnet is deleted (or if its removed from VPN), the ports that are DOWN on that subnet
+ * will continue to be stale in portOpData DS, as subDpnList used for portOpData removal will
+ * contain only ports that are UP. So here we explicitly cleanup the ports of the subnet by
+ * going through the list of ports on the subnet
+ */
+ List<Uuid> portList = subnetmap.getPortList();
+ if (portList != null) {
+ for (Uuid port : portList) {
+ InstanceIdentifier<PortOpDataEntry> portOpIdentifier =
+ InstanceIdentifier.builder(PortOpData.class).child(PortOpDataEntry.class,
+ new PortOpDataEntryKey(port.getValue())).build();
+ LOG.trace("{} onSubnetDeletedFromVpn: Deleting portOpData entry for port {}"
+ + " from subnet {} subnetIp {} vpnName {} TaskState {}",
+ LOGGING_PREFIX, port.getValue(), subnetId.getValue(),
+ optionalSubs.get().getSubnetCidr(), optionalSubs.get().getVpnName(),
+ optionalSubs.get().getRouteAdvState());
+ SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL,
+ portOpIdentifier, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
}
}
deleteSubnetRouteFromFib(rd, subnetIp, vpnName, isBgpVpn);
SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier,
VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
+ int releasedLabel = vpnUtil.releaseId(VpnConstants.VPN_IDPOOL_NAME,
+ VpnUtil.getNextHopLabelKey(rd, subnetIp));
+ if (releasedLabel == VpnConstants.INVALID_LABEL) {
+ LOG.error("onSubnetDeletedFromVpn: Unable to release label for key {}",
+ VpnUtil.getNextHopLabelKey(rd, subnetIp));
+ }
LOG.info("{} onSubnetDeletedFromVpn: Removed subnetopdataentry successfully from Datastore"
+ " for subnet {} subnetIp {} vpnName {} rd {}", LOGGING_PREFIX, subnetId.getValue(),
subnetIp, vpnName, rd);
String subnetIp = optionalSubs.get().getSubnetCidr();
String rd = optionalSubs.get().getVrfId();
String routeAdvState = optionalSubs.get().getRouteAdvState().toString();
+ Uint32 label = optionalSubs.get().getLabel();
LOG.info("{} onPortAddedToSubnet: Port {} being added to subnet {} subnetIp {} vpnName {} rd {} "
+ "TaskState {}", LOGGING_PREFIX, portId.getValue(), subnetId.getValue(), subnetIp,
vpnName, rd, routeAdvState);
if (subOpBuilder.getNhDpnId() == null) {
// No nexthop selected yet, elect one now
electNewDpnForSubnetRoute(subOpBuilder, null /* oldDpnId */, subnetId,
- subnetmap.getNetworkId(), true);
+ subnetmap.getNetworkId(), true, label);
} else if (!VpnUtil.isExternalSubnetVpn(subnetOpDataEntry.getVpnName(), subnetId.getValue())) {
// Already nexthop has been selected, only publishing to bgp required, so publish to bgp
getNexthopTepAndPublishRoute(subOpBuilder, subnetId);
subOpBuilder.getSubnetCidr(), subOpBuilder.getVpnName(), subOpBuilder.getVrfId());
// last port on this DPN, so we need to elect the new NHDpnId
electNewDpnForSubnetRoute(subOpBuilder, nhDpnId, subnetId, subnetmap.getNetworkId(),
- !VpnUtil.isExternalSubnetVpn(subnetOpDataEntry.getVpnName(), subnetId.getValue()));
+ !VpnUtil.isExternalSubnetVpn(subnetOpDataEntry.getVpnName(), subnetId.getValue()),
+ subOpBuilder.getLabel());
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
subOpIdentifier, subOpBuilder.build(), VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
LOG.info("{} onPortRemovedFromSubnet: Updated subnetopdataentry to OP Datastore"
List<SubnetToDpn> subnetToDpnList = concat(new ArrayList<SubnetToDpn>(subnetOpDataEntry
.nonnullSubnetToDpn().values()), subDpn);
subOpBuilder.setSubnetToDpn(getSubnetToDpnMap(subnetToDpnList));
+ Uint32 label = optionalSubs.get().getLabel();
if (subOpBuilder.getRouteAdvState() != TaskState.Advertised) {
if (subOpBuilder.getNhDpnId() == null) {
// No nexthop selected yet, elect one now
electNewDpnForSubnetRoute(subOpBuilder, null /* oldDpnId */, subnetId,
- null /*networkId*/, !isExternalSubnetVpn);
+ null /*networkId*/, !isExternalSubnetVpn, label);
} else if (!isExternalSubnetVpn) {
// Already nexthop has been selected, only publishing to bgp required, so publish to bgp
getNexthopTepAndPublishRoute(subOpBuilder, subnetId);
subOpBuilder.getSubnetCidr(), subOpBuilder.getVpnName(), subOpBuilder.getVrfId());
// last port on this DPN, so we need to elect the new NHDpnId
electNewDpnForSubnetRoute(subOpBuilder, dpnId, subnetId, null /*networkId*/,
- !VpnUtil.isExternalSubnetVpn(subnetOpDataEntry.getVpnName(), subnetId.getValue()));
+ !VpnUtil.isExternalSubnetVpn(subnetOpDataEntry.getVpnName(), subnetId.getValue()),
+ subOpBuilder.getLabel());
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL,
subOpIdentifier, subOpBuilder.build(), VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
LOG.info("{} onInterfaceDown: Updated subnetopdataentry for subnet {} subnetIp {} vpnName {}"
optionalSubs.get().getLastAdvState(), dpnId.toString());
SubnetOpDataEntry subOpEntry = optionalSubs.get();
SubnetOpDataEntryBuilder subOpBuilder = new SubnetOpDataEntryBuilder(subOpEntry);
+ Uint32 label = optionalSubs.get().getLabel();
boolean isExternalSubnetVpn = VpnUtil.isExternalSubnetVpn(subOpEntry.getVpnName(), subnetId.getValue());
if (subOpBuilder.getRouteAdvState() != TaskState.Advertised) {
if (subOpBuilder.getNhDpnId() == null) {
// No nexthop selected yet, elect one now
electNewDpnForSubnetRoute(subOpBuilder, null /* oldDpnId */, subnetId,
- null /*networkId*/, !isExternalSubnetVpn);
+ null /*networkId*/, !isExternalSubnetVpn, label);
} else if (!isExternalSubnetVpn) {
// Already nexthop has been selected, only publishing to bgp required, so publish to bgp
getNexthopTepAndPublishRoute(subOpBuilder, subnetId);
SubnetOpDataEntry subOpEntry = null;
SubnetOpDataEntryBuilder subOpBuilder = new SubnetOpDataEntryBuilder(optionalSubs.get());
Uint64 nhDpnId = subOpBuilder.getNhDpnId();
+ Uint32 label = optionalSubs.get().getLabel();
if (nhDpnId != null && nhDpnId.equals(dpnId)) {
- electNewDpnForSubnetRoute(subOpBuilder, dpnId, subnetId, null /*networkId*/, true);
+ electNewDpnForSubnetRoute(subOpBuilder, dpnId, subnetId, null /*networkId*/, true,
+ label);
subOpEntry = subOpBuilder.build();
SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.OPERATIONAL, subOpIdentifier,
subOpEntry, VpnUtil.SINGLE_TRANSACTION_BROKER_NO_RETRY);
subOpBuilder.setLastAdvState(subOpBuilder.getRouteAdvState()).setRouteAdvState(TaskState.Advertised);
} catch (Exception e) {
LOG.error("{} publishSubnetRouteToBgp: Subnet route not advertised for subnet {} subnetIp {} vpn {} rd {}"
- + " with dpnid {}", LOGGING_PREFIX, subOpBuilder.getSubnetId().getValue(),
+ + " with dpnid {}", LOGGING_PREFIX, subOpBuilder.getSubnetId().getValue(),
subOpBuilder.getSubnetCidr(), subOpBuilder.getVpnName(), subOpBuilder.getVrfId(), nextHopIp, e);
}
}
LOG.warn("Unable to find nexthopip for rd {} subnetroute subnetip {} for dpnid {}",
subOpBuilder.getVrfId(), subOpBuilder.getSubnetCidr(),
subOpBuilder.getNhDpnId().toString());
- electNewDpnForSubnetRoute(subOpBuilder, null /* oldDpnId */, subnetId, null /*networkId*/, true);
+ electNewDpnForSubnetRoute(subOpBuilder, null /* oldDpnId */, subnetId, null /*networkId*/,
+ true, subOpBuilder.getLabel());
}
}
return true;
}
+ @SuppressFBWarnings
private Uint32 getLabel(String rd, String subnetIp) {
Uint32 label = vpnUtil.getUniqueId(VpnConstants.VPN_IDPOOL_NAME, VpnUtil.getNextHopLabelKey(rd, subnetIp));
LOG.trace("{} getLabel: Allocated subnetroute label {} for rd {} prefix {}", LOGGING_PREFIX, label, rd,
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
private void electNewDpnForSubnetRoute(SubnetOpDataEntryBuilder subOpBuilder, @Nullable Uint64 oldDpnId,
- Uuid subnetId, Uuid networkId, boolean isBgpVpn) {
+ Uuid subnetId, Uuid networkId, boolean isBgpVpn, Uint32 label) {
boolean isRouteAdvertised = false;
String rd = subOpBuilder.getVrfId();
String subnetIp = subOpBuilder.getSubnetCidr();
long elanTag = subOpBuilder.getElanTag().toJava();
boolean isAlternateDpnSelected = false;
Uint32 l3vni = Uint32.ZERO;
- Uint32 label = Uint32.ZERO;
String networkName = networkId != null ? networkId.getValue() : null;
- LOG.info("{} electNewDpnForSubnetRoute: Handling subnet {} subnetIp {} vpn {} rd {} TaskState {}"
- + " lastTaskState {}", LOGGING_PREFIX, subnetId.getValue(), subnetIp, subOpBuilder.getVpnName(),
- subOpBuilder.getVrfId(), subOpBuilder.getRouteAdvState(), subOpBuilder.getLastAdvState());
+ LOG.info("{} electNewDpnForSubnetRoute: Handling subnet {} subnetIp {} vpn {} rd {} label {} TaskState {}"
+ + " lastTaskState {}", LOGGING_PREFIX, subnetId.getValue(), subnetIp, subOpBuilder.getVpnName(),
+ subOpBuilder.getVrfId(), label, subOpBuilder.getRouteAdvState(), subOpBuilder.getLastAdvState());
if (!isBgpVpn) {
// Non-BGPVPN as it stands here represents use-case of External Subnets of VLAN-Provider-Network
// TODO(Tomer): Pulling in both external and internal VLAN-Provider-Network need to be
if (VpnUtil.isL3VpnOverVxLan(subOpBuilder.getL3vni())) {
l3vni = subOpBuilder.getL3vni();
} else {
- label = getLabel(rd, subnetIp);
subOpBuilder.setLabel(label);
}
isRouteAdvertised = addSubnetRouteToFib(rd, subnetIp, null /* nhDpnId */, null /* nhTepIp */,
subOpBuilder.setRouteAdvState(TaskState.Advertised);
} else {
LOG.error("{} electNewDpnForSubnetRoute: Unable to find TepIp for subnet {} subnetip {} vpnName {}"
- + " rd {}, attempt next dpn", LOGGING_PREFIX, subnetId.getValue(), subnetIp,
- vpnName, rd);
+ + " rd {}, attempt next dpn", LOGGING_PREFIX, subnetId.getValue(), subnetIp,
+ vpnName, rd);
subOpBuilder.setRouteAdvState(TaskState.PendingAdvertise);
}
return;
//If no alternate Dpn is selected as nextHopDpn, withdraw the subnetroute if it had a nextHop already.
if (isRouteAdvertised(subOpBuilder) && oldDpnId != null) {
LOG.info("{} electNewDpnForSubnetRoute: No alternate DPN available for subnet {} subnetIp {} vpn {}"
- + " rd {} Prefix withdrawn from BGP", LOGGING_PREFIX, subnetId.getValue(), subnetIp, vpnName,
- rd);
+ + " rd {} Prefix withdrawn from BGP", LOGGING_PREFIX, subnetId.getValue(), subnetIp,
+ vpnName, rd);
// Withdraw route from BGP for this subnet
boolean routeWithdrawn = deleteSubnetRouteFromFib(rd, subnetIp, vpnName, isBgpVpn);
//subOpBuilder.setNhDpnId(Uint64.valueOf(null));
subOpBuilder.setRouteAdvState(TaskState.Withdrawn);
} else {
LOG.error("{} electNewDpnForSubnetRoute: Withdrawing NextHopDPN {} for subnet {} subnetIp {}"
- + " vpn {} rd {} from BGP failed", LOGGING_PREFIX, oldDpnId, subnetId.getValue(),
- subnetIp, vpnName, rd);
+ + " vpn {} rd {} from BGP failed", LOGGING_PREFIX, oldDpnId, subnetId.getValue(),
+ subnetIp, vpnName, rd);
subOpBuilder.setRouteAdvState(TaskState.PendingWithdraw);
}
}
if (VpnUtil.isL3VpnOverVxLan(subOpBuilder.getL3vni())) {
l3vni = subOpBuilder.getL3vni();
} else {
- label = getLabel(rd, subnetIp);
subOpBuilder.setLabel(label);
}
//update the VRF entry for the subnetroute.
}
static InstanceIdentifier<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntryIdentifier(String vpnInterfaceName,
- String vpnName) {
+ String vpnName) {
return InstanceIdentifier.builder(VpnInterfaceOpData.class).child(VpnInterfaceOpDataEntry.class,
- new VpnInterfaceOpDataEntryKey(vpnInterfaceName, vpnName)).build();
+ new VpnInterfaceOpDataEntryKey(vpnInterfaceName, vpnName)).build();
}
static InstanceIdentifier<VpnInstance> getVpnInstanceIdentifier(String vpnName) {
Optional<VpnInterfaceOpDataEntry> getVpnInterfaceOpDataEntry(String vpnInterfaceName, String vpnName) {
InstanceIdentifier<VpnInterfaceOpDataEntry> id = getVpnInterfaceOpDataEntryIdentifier(vpnInterfaceName,
- vpnName);
+ vpnName);
Optional<VpnInterfaceOpDataEntry> vpnInterfaceOpDataEntry = read(LogicalDatastoreType.OPERATIONAL,
id);
return vpnInterfaceOpDataEntry;
}
static Prefixes getPrefixToInterface(Uint64 dpId, String vpnInterfaceName, String ipPrefix,
- Uuid networkId, NetworkType networkType, Long segmentationId, Prefixes.PrefixCue prefixCue) {
+ Uuid networkId, NetworkType networkType, Long segmentationId,
+ Prefixes.PrefixCue prefixCue) {
return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(
- vpnInterfaceName).setIpAddress(ipPrefix)//.setSubnetId(subnetId)
+ vpnInterfaceName).setIpAddress(ipPrefix)//.setSubnetId(subnetId)
.setNetworkId(networkId).setNetworkType(networkType).setSegmentationId(segmentationId)
.setPrefixCue(prefixCue).build();
}
static Prefixes getPrefixToInterface(Uint64 dpId, String vpnInterfaceName, String ipPrefix,
- Prefixes.PrefixCue prefixCue) {
+ Prefixes.PrefixCue prefixCue) {
return new PrefixesBuilder().setDpnId(dpId).setVpnInterfaceName(vpnInterfaceName).setIpAddress(ipPrefix)
.setPrefixCue(prefixCue).build();
}
@Nullable
public VpnInstance getVpnInstance(String vpnInstanceName) {
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class).child(VpnInstance.class,
- new VpnInstanceKey(vpnInstanceName)).build();
+ new VpnInstanceKey(vpnInstanceName)).build();
Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
return vpnInstance.isPresent() ? vpnInstance.get() : null;
}
Optional<VpnToDpnList> dpnInVpn = read(LogicalDatastoreType.OPERATIONAL, dpnToVpnId);
return dpnInVpn.isPresent() && dpnInVpn.get().getVpnInterfaces() != null
? new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op
- .data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces>(dpnInVpn.get()
- .getVpnInterfaces().values())
- : emptyList();
+ .data.vpn.instance.op.data.entry.vpn.to.dpn.list.VpnInterfaces>(dpnInVpn.get()
+ .getVpnInterfaces().values())
+ : emptyList();
}
@NonNull
// 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();
+ InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).child(
+ VrfEntry.class, new VrfEntryKey(ipPrefix)).build();
Optional<VrfEntry> vrfEntry = read(LogicalDatastoreType.CONFIGURATION, vrfEntryId);
if (vrfEntry.isPresent()) {
return vrfEntry.get();
return Uint32.ZERO;
}
- void releaseId(String poolName, String idKey) {
+ Integer releaseId(String poolName, String idKey) {
ReleaseIdInput idInput = new ReleaseIdInputBuilder().setPoolName(poolName).setIdKey(idKey).build();
try {
- 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());
+ Future<RpcResult<ReleaseIdOutput>> result = idManager.releaseId(idInput);
+ if (result == null || result.get() == null || !result.get().isSuccessful()) {
+ LOG.error("releaseId: RPC Call to release Id from pool {} with key {} returned with Errors {}",
+ poolName, idKey,
+ (result != null && result.get() != null) ? result.get().getErrors() : "RpcResult is null");
+ } else {
+ return result.get().getResult().getIdValues().get(0).intValue();
}
} catch (InterruptedException | ExecutionException e) {
LOG.error("releaseId: Exception when releasing Id for key {} from pool {}", idKey, poolName, e);
}
+ return VpnConstants.INVALID_IDMAN_ID;
}
public static String getNextHopLabelKey(String rd, String prefix) {
return read(LogicalDatastoreType.CONFIGURATION, VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName))
.map(org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911
.vpn.instance.to.vpn.id.VpnInstance::getVpnId)
- .orElse(VpnConstants.INVALID_ID);
+ .orElse(VpnConstants.INVALID_ID);
}
/**
*/
public String getVpnRd(String vpnName) {
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.to.vpn.id
- .VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION,
+ .VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION,
VpnOperDsUtils.getVpnInstanceToVpnIdIdentifier(vpnName));
String rd = null;
if (vpnInstance.isPresent()) {
List<String> getVpnRdsFromVpnInstanceConfig(String vpnName) {
InstanceIdentifier<VpnInstance> id = InstanceIdentifier.builder(VpnInstances.class)
- .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
+ .child(VpnInstance.class, new VpnInstanceKey(vpnName)).build();
Optional<VpnInstance> vpnInstance = read(LogicalDatastoreType.CONFIGURATION, id);
return vpnInstance.isPresent() ? getListOfRdsFromVpnInstance(vpnInstance.get()) : new ArrayList<>();
}
*/
public void removeVrfEntriesByOrigin(String rd, RouteOrigin origin) {
InstanceIdentifier<VrfTables> vpnVrfTableIid =
- InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
+ InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
Optional<VrfTables> vrfTablesOpc = read(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
if (vrfTablesOpc.isPresent()) {
VrfTables vrfTables = vrfTablesOpc.get();
LoggingFutures.addErrorLogging(
new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
- Datastore.CONFIGURATION, tx -> {
+ Datastore.CONFIGURATION, tx -> {
for (VrfEntry vrfEntry : vrfTables.nonnullVrfEntry().values()) {
if (origin == RouteOrigin.value(vrfEntry.getOrigin())) {
tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
public List<VrfEntry> findVrfEntriesByNexthop(String rd, String nexthop) {
InstanceIdentifier<VrfTables> vpnVrfTableIid =
- InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
+ InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
Optional<VrfTables> vrfTablesOpc = read(LogicalDatastoreType.CONFIGURATION, vpnVrfTableIid);
List<VrfEntry> matches = new ArrayList<>();
if (vrfTablesOpc.isPresent()) {
public void removeVrfEntries(String rd, List<VrfEntry> vrfEntries) {
InstanceIdentifier<VrfTables> vpnVrfTableIid =
- InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
+ InstanceIdentifier.builder(FibEntries.class).child(VrfTables.class, new VrfTablesKey(rd)).build();
LoggingFutures.addErrorLogging(
new ManagedNewTransactionRunnerImpl(dataBroker).callWithNewWriteOnlyTransactionAndSubmit(
- Datastore.CONFIGURATION, tx -> {
+ Datastore.CONFIGURATION, tx -> {
for (VrfEntry vrfEntry : vrfEntries) {
tx.delete(vpnVrfTableIid.child(VrfEntry.class, vrfEntry.key()));
}
bgpManager.withdrawPrefix(rd, vrfEntry.getDestPrefix());
} catch (Exception e) {
LOG.error("withdrawRoutes: Could not withdraw route to {} with route-paths {} in VpnRd {}",
- vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths(), rd);
+ vrfEntry.getDestPrefix(), vrfEntry.getRoutePaths(), rd);
}
});
}
static org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds
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)
+ .VpnIdsBuilder().setVpnId(vpnId).setVpnInstanceName(vpnName).setVrfId(rd).setExternalVpn(isExternalVpn)
.build();
}
static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to
- .vpn.instance.VpnIds> getVpnIdToVpnInstanceIdentifier(Uint32 vpnId) {
+ .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,
+ .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();
+ .VpnIdsKey(vpnId)).build();
}
/**
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(LogicalDatastoreType.CONFIGURATION, id);
+ vpnInstance
+ = read(LogicalDatastoreType.CONFIGURATION, id);
String vpnName = null;
if (vpnInstance.isPresent()) {
vpnName = vpnInstance.get().getVpnInstanceName();
public static InstanceIdentifier<VpnInstanceOpDataEntry> getVpnInstanceOpDataIdentifier(String rd) {
return InstanceIdentifier.builder(VpnInstanceOpData.class)
- .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
+ .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(rd)).build();
}
@Nullable
if (optConfiguredVpnInterface.isPresent()) {
VpnInterface cfgVpnInterface = optConfiguredVpnInterface.get();
java.util.Optional<List<VpnInstanceNames>> optVpnInstanceList =
- java.util.Optional.ofNullable(
- new ArrayList<VpnInstanceNames>(cfgVpnInterface.nonnullVpnInstanceNames().values()));
+ java.util.Optional.ofNullable(
+ new ArrayList<VpnInstanceNames>(cfgVpnInterface.nonnullVpnInstanceNames().values()));
if (optVpnInstanceList.isPresent()) {
List<String> vpnList = new ArrayList<>();
for (VpnInstanceNames vpnInstance : optVpnInstanceList.get()) {
}
static final FutureCallback<Void> DEFAULT_CALLBACK =
- new FutureCallback<Void>() {
+ new FutureCallback<Void>() {
@Override
- public void onSuccess(Void result) {
+ public void onSuccess(Void result) {
LOG.debug("Success in Datastore operation");
}
@Override
- public void onFailure(Throwable error) {
+ public void onFailure(Throwable error) {
LOG.error("Error in Datastore operation", error);
}
static InstanceIdentifier<IfIndexInterface> getInterfaceInfoEntriesOperationalDataPath(long interfaceTag) {
return InstanceIdentifier.builder(IfIndexesInterfaceMap.class).child(IfIndexInterface.class,
- new IfIndexInterfaceKey((int) interfaceTag)).build();
+ new IfIndexInterfaceKey((int) interfaceTag)).build();
}
@Nullable
static InstanceIdentifier<ElanTagName> getElanInfoEntriesOperationalDataPath(long elanTag) {
return InstanceIdentifier.builder(ElanTagNameMap.class).child(ElanTagName.class,
- new ElanTagNameKey(elanTag)).build();
+ new ElanTagNameKey(elanTag)).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());
+ PrefixToInterface.class).child(VpnIds.class, new VpnIdsKey(vpnId)).build());
}
static void removeVpnExtraRouteForVpn(String vpnName, @NonNull TypedWriteTransaction<Operational> operTx) {
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());
+ VpnNexthops.class, new VpnNexthopsKey(vpnId)).build());
}
void scheduleVpnInterfaceForRemoval(String interfaceName, Uint64 dpnId, String vpnInstanceName,
InstanceIdentifier<VpnInterfaceOpDataEntry> interfaceId =
getVpnInterfaceOpDataEntryIdentifier(interfaceName, vpnInstanceName);
VpnInterfaceOpDataEntry interfaceToUpdate =
- new VpnInterfaceOpDataEntryBuilder().withKey(new VpnInterfaceOpDataEntryKey(interfaceName,
- vpnInstanceName)).setName(interfaceName).setDpnId(dpnId).setVpnInstanceName(vpnInstanceName)
- .build();
+ new VpnInterfaceOpDataEntryBuilder().withKey(new VpnInterfaceOpDataEntryKey(interfaceName,
+ vpnInstanceName)).setName(interfaceName).setDpnId(dpnId).setVpnInstanceName(vpnInstanceName)
+ .build();
if (writeOperTxn != null) {
writeOperTxn.mergeParentStructureMerge(interfaceId, interfaceToUpdate);
} else {
}
public void createLearntVpnVipToPort(String vpnName, String fixedIp, String portName, String macAddress,
- TypedWriteTransaction<Operational> writeOperTxn) {
+ TypedWriteTransaction<Operational> writeOperTxn) {
final InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, fixedIp);
final ReentrantLock lock = lockFor(vpnName, fixedIp);
lock.lock();
}
static InstanceIdentifier<LearntVpnVipToPort> buildLearntVpnVipToPortIdentifier(String vpnName,
- String fixedIp) {
+ String fixedIp) {
return InstanceIdentifier.builder(LearntVpnVipToPortData.class).child(LearntVpnVipToPort.class,
new LearntVpnVipToPortKey(fixedIp, vpnName)).build();
}
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
}
LOG.debug("removeLearntVpnVipToPort: Deleted LearntVpnVipToPort entry for fixedIp: {}, vpn {}",
- fixedIp, vpnName);
+ fixedIp, vpnName);
} finally {
lock.unlock();
}
}
public static void removeVpnPortFixedIpToPort(DataBroker broker, String vpnName, String fixedIp,
- @Nullable TypedWriteTransaction<Configuration> writeConfigTxn) {
+ @Nullable TypedWriteTransaction<Configuration> writeConfigTxn) {
final InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
final ReentrantLock lock = lockFor(vpnName, fixedIp);
lock.lock();
MDSALUtil.syncDelete(broker, LogicalDatastoreType.CONFIGURATION, id);
}
LOG.debug("removeVpnPortFixedIpToPort: Deleted VpnPortipToPort entry for fixedIp: {}, vpn {}",
- fixedIp, vpnName);
+ fixedIp, vpnName);
} finally {
lock.unlock();
}
}
public void removeLearntVpnVipToPortEvent(String eventId,
- @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
+ @Nullable TypedWriteTransaction<Operational> writeOperTxn) {
InstanceIdentifier<LearntVpnVipToPortEvent> id = buildLearntVpnVipToPortEventIdentifier(eventId);
if (writeOperTxn != null) {
writeOperTxn.delete(id);
.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);
+ vpnInterface, vpnName);
}
InstanceIdentifier<LearntVpnVipToPort> id = buildLearntVpnVipToPortIdentifier(vpnName, prefix);
MDSALUtil.syncDelete(dataBroker, LogicalDatastoreType.OPERATIONAL, id);
@Nullable
public static VpnPortipToPort getNeutronPortFromVpnPortFixedIp(TypedReadTransaction<Configuration> confTx,
- String vpnName, String fixedIp) {
+ String vpnName, String fixedIp) {
InstanceIdentifier<VpnPortipToPort> id = buildVpnPortipToPortIdentifier(vpnName, fixedIp);
try {
return confTx.read(id).get().orElse(null);
Subnet neutronSubnet = neutronVpnService.getNeutronSubnet(externalIp.getSubnetId());
if (neutronSubnet == null) {
LOG.warn("Failed to retrieve subnet {} referenced by router {}",
- externalIp.getSubnetId(), routerData);
+ externalIp.getSubnetId(), routerData);
continue;
}
if (NWUtil.isIpAddressInRange(IpAddressBuilder.getDefaultInstance(extIp),
@Nullable
Networks getExternalNetwork(Uuid networkId) {
InstanceIdentifier<Networks> netsIdentifier = InstanceIdentifier.builder(ExternalNetworks.class)
- .child(Networks.class, new NetworksKey(networkId)).build();
+ .child(Networks.class, new NetworksKey(networkId)).build();
Optional<Networks> optionalNets = read(LogicalDatastoreType.CONFIGURATION, netsIdentifier);
return optionalNets.isPresent() ? optionalNets.get() : null;
}
Routers getExternalRouter(TypedReadTransaction<Configuration> tx, String routerId)
throws ExecutionException, InterruptedException {
InstanceIdentifier<Routers> id = InstanceIdentifier.builder(ExtRouters.class).child(Routers.class,
- new RoutersKey(routerId)).build();
+ new RoutersKey(routerId)).build();
return tx.read(id).get().orElse(null);
}
}
FlowEntity buildL3vpnGatewayFlow(Uint64 dpId, String gwMacAddress, Uint32 vpnId,
- Uint32 subnetVpnId) {
+ Uint32 subnetVpnId) {
List<MatchInfo> mkMatches = new ArrayList<>();
Subnetmap smap = null;
mkMatches.add(new MatchMetadata(MetaDataUtil.getVpnIdMetadata(vpnId.longValue()),
- MetaDataUtil.METADATA_MASK_VRFID));
+ MetaDataUtil.METADATA_MASK_VRFID));
mkMatches.add(new MatchEthernetDestination(new MacAddress(gwMacAddress)));
List<InstructionInfo> mkInstructions = new ArrayList<>();
mkInstructions.add(new InstructionGotoTable(NwConstants.L3_FIB_TABLE));
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 + subnetVpnId;
+ + NwConstants.FLOWID_SEPARATOR + l3GwMacTable + NwConstants.FLOWID_SEPARATOR + subnetVpnId;
}
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(9000L).setTimeUnit(TimeUnits.Milliseconds).build();
+ new TryLockInputBuilder().setLockName(subnetId).setTime(9000L)
+ .setTimeUnit(TimeUnits.Milliseconds).build();
Future<RpcResult<TryLockOutput>> result = lockManager.tryLock(input);
try {
if (result != null && result.get().isSuccessful()) {
Optional<String> gatewayMac = Optional.empty();
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);
+ .instance.VpnIds>
+ vpnIdsInstanceIdentifier = VpnUtil.getVpnIdToVpnInstanceIdentifier(vpnId);
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance.VpnIds>
- vpnIdsOptional = read(LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
+ vpnIdsOptional = read(LogicalDatastoreType.CONFIGURATION, vpnIdsInstanceIdentifier);
if (!vpnIdsOptional.isPresent()) {
LOG.error("getGWMacAddressFromInterface: VPN {} not configured", vpnId);
return gatewayMac;
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);
+ .VpnIds> vpnIdsInstanceIdentifier = getVpnIdToVpnInstanceIdentifier(vpnId);
Optional<org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.id.to.vpn.instance
- .VpnIds> vpnIdsOptional = writeInvTxn.read(vpnIdsInstanceIdentifier).get();
+ .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 {}",
static InstanceIdentifier<Subnetmap> buildSubnetmapIdentifier(Uuid subnetId) {
return InstanceIdentifier.builder(Subnetmaps.class)
- .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
+ .child(Subnetmap.class, new SubnetmapKey(subnetId)).build();
}
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();
+ .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) {
void bindService(final String vpnInstanceName, final String interfaceName, boolean isTunnelInterface) {
jobCoordinator.enqueueJob(interfaceName,
() -> Collections.singletonList(txRunner.callWithNewReadWriteTransactionAndSubmit(
- Datastore.CONFIGURATION, tx -> {
+ Datastore.CONFIGURATION, tx -> {
BoundServices serviceInfo = isTunnelInterface
- ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
- : getBoundServicesForVpnInterface(vpnInstanceName, interfaceName);
+ ? VpnUtil.getBoundServicesForTunnelInterface(vpnInstanceName, interfaceName)
+ : getBoundServicesForVpnInterface(vpnInstanceName, interfaceName);
tx.mergeParentStructurePut(InterfaceUtils.buildServiceId(interfaceName,
- ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
- NwConstants.L3VPN_SERVICE_INDEX)),
- serviceInfo);
+ ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
+ NwConstants.L3VPN_SERVICE_INDEX)),
+ serviceInfo);
})), SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
}
final Uint32 vpnId = getVpnId(vpnName);
List<Action> actions = Collections.singletonList(
new ActionRegLoad(0, VpnConstants.VPN_REG_ID, 0, VpnConstants.VPN_ID_LENGTH, vpnId.longValue())
- .buildAction());
+ .buildAction());
instructions.add(MDSALUtil.buildApplyActionsInstruction(actions, ++instructionKey));
instructions.add(
MDSALUtil.buildAndGetWriteMetadaInstruction(MetaDataUtil.getVpnIdMetadata(vpnId.longValue()),
if (!isInterfaceStateDown) {
jobCoordinator.enqueueJob(vpnInterfaceName,
() -> Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
- Datastore.CONFIGURATION, tx ->
- tx.delete(InterfaceUtils.buildServiceId(vpnInterfaceName,
- ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
- NwConstants.L3VPN_SERVICE_INDEX))))),
- SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
+ Datastore.CONFIGURATION, tx ->
+ tx.delete(InterfaceUtils.buildServiceId(vpnInterfaceName,
+ ServiceIndex.getIndex(NwConstants.L3VPN_SERVICE_NAME,
+ NwConstants.L3VPN_SERVICE_INDEX))))),
+ SystemPropertyReader.getDataStoreJobCoordinatorMaxRetries());
}
}
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)
+ .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 = read(LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
+ optionalSubnets = read(LogicalDatastoreType.CONFIGURATION, subnetsIdentifier);
return optionalSubnets.isPresent() ? optionalSubnets.get() : null;
}
}
public static boolean isEligibleForBgp(@Nullable String rd, @Nullable String vpnName, @Nullable Uint64 dpnId,
- @Nullable String networkName) {
+ @Nullable String networkName) {
if (rd != null) {
if (rd.equals(vpnName)) {
return false;
};
Predicate<VpnInstanceOpDataEntry> matchRTs = input -> {
Iterable<String> commonRTs =
- intersection(getRts(vpnInstanceOpDataEntry, VpnTarget.VrfRTType.ExportExtcommunity),
- getRts(input, VpnTarget.VrfRTType.ImportExtcommunity));
+ intersection(getRts(vpnInstanceOpDataEntry, VpnTarget.VrfRTType.ExportExtcommunity),
+ getRts(input, VpnTarget.VrfRTType.ImportExtcommunity));
return Iterators.size(commonRTs.iterator()) > 0;
};
vpnsToImportRoute = getAllVpnInstanceOpData().stream().filter(excludeVpn).filter(matchRTs)
return false;
}
InstanceIdentifier<VpnInstanceOpDataEntry> id = InstanceIdentifier.builder(VpnInstanceOpData.class)
- .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(primaryRd)).build();
+ .child(VpnInstanceOpDataEntry.class, new VpnInstanceOpDataEntryKey(primaryRd)).build();
Optional<VpnInstanceOpDataEntry> vpnInstanceOpDataEntryOptional = read(LogicalDatastoreType.OPERATIONAL, id);
if (!vpnInstanceOpDataEntryOptional.isPresent()) {
LOG.error("isBgpVpnInternet VPN {}."
- + "VpnInstanceOpDataEntry not found", vpnName);
+ + "VpnInstanceOpDataEntry not found", vpnName);
return false;
}
LOG.debug("isBgpVpnInternet VPN {} Successfully VpnInstanceOpDataEntry.getBgpvpnType {}",
- vpnName, vpnInstanceOpDataEntryOptional.get().getBgpvpnType());
+ vpnName, vpnInstanceOpDataEntryOptional.get().getBgpvpnType());
if (vpnInstanceOpDataEntryOptional.get().getBgpvpnType() == VpnInstanceOpDataEntry.BgpvpnType.InternetBGPVPN) {
return true;
}
* @param vpnName the vpn name
*/
void removeRouterPortFromElanDpnListForVlanInAllDpn(String elanInstanceName,
- String routerInterfacePortId, String vpnName) {
+ String routerInterfacePortId, String vpnName) {
Map<String,String> elanInstanceRouterPortMap = getElanInstanceRouterPortMap(vpnName);
elanInstanceRouterPortMap.put(elanInstanceName, routerInterfacePortId);
Set<Uint64> dpnList = getDpnInElan(elanInstanceRouterPortMap);
}
void removeRouterPortFromElanDpn(String elanInstanceName, String routerInterfacePortId,
- String vpnName, Uint64 dpnId) {
+ String vpnName, Uint64 dpnId) {
InstanceIdentifier<DpnInterfaces> elanDpnInterfaceId = getElanDpnInterfaceOperationalDataPath(
elanInstanceName,dpnId);
final ReentrantLock lock = JvmGlobalLocks.getLockForString(elanInstanceName);
}
public static InstanceIdentifier<DpnInterfaces> getElanDpnInterfaceOperationalDataPath(String elanInstanceName,
- Uint64 dpId) {
+ Uint64 dpId) {
return InstanceIdentifier.builder(ElanDpnInterfaces.class)
.child(ElanDpnInterfacesList.class, new ElanDpnInterfacesListKey(elanInstanceName))
.child(DpnInterfaces.class, new DpnInterfacesKey(dpId)).build();
}
public static void sendNeighborSolicationToOfGroup(Ipv6NdUtilService ipv6NdUtilService, Ipv6Address srcIpv6Address,
- MacAddress srcMac, Ipv6Address dstIpv6Address, Long ofGroupId, Uint64 dpId) {
+ MacAddress srcMac, Ipv6Address dstIpv6Address, Long ofGroupId,
+ Uint64 dpId) {
SendNeighborSolicitationToOfGroupInput input = new SendNeighborSolicitationToOfGroupInputBuilder()
.setSourceIpv6(srcIpv6Address).setSourceLlAddress(srcMac).setTargetIpAddress(dstIpv6Address)
.setOfGroupId(ofGroupId).setDpId(dpId).build();
}
static InstanceIdentifier<AssociatedSubnet> getAssociatedSubnetIdentifier(String rt, RouteTarget.RtType rtType,
- String cidr) {
+ String cidr) {
return InstanceIdentifier.builder(SubnetsAssociatedToRouteTargets.class).child(RouteTarget.class,
new RouteTargetKey(rt, rtType)).child(AssociatedSubnet.class, new AssociatedSubnetKey(cidr)).build();
}
// TODO Clean up the exception handling
@SuppressWarnings("checkstyle:IllegalCatch")
public void createVpnPortFixedIpToPort(String vpnName, String fixedIp,
- String portName, boolean isLearntIp, String macAddress,
- WriteTransaction writeConfigTxn) {
+ 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)
Uint32 label = Uint32.valueOf(input.getLabel());
Uint32 l3vni = Uint32.valueOf(input.getL3vni());
Uint32 elantag = Uint32.valueOf(input.getElanTag());
- Uint64 dpnId = input.getDpnId();
String networkName = input.getNetworkName();
String gwMacAddress = input.getGatewayMac();
SubnetRoute route = new SubnetRouteBuilder().setElantag(elantag).build();
//Will be handled appropriately with the iRT patch for EVPN
if (input.getEncapType().equals(VrfEntryBase.EncapType.Mplsgre)) {
- Uint32 vpnId = vpnUtil.getVpnId(vpnName);
- addToLabelMapper(label, dpnId, prefix, Collections.singletonList(nextHop), vpnId, null,
- elantag, true, rd);
List<VpnInstanceOpDataEntry> vpnsToImportRoute = vpnUtil.getVpnsImportingMyRoute(vpnName);
if (vpnsToImportRoute.size() > 0) {
VrfEntry importingVrfEntry = FibHelper.getVrfEntryBuilder(prefix, label, nextHop,
.setVrfEntry(importingVrfEntryList).build();
vpnUtil.syncUpdate(LogicalDatastoreType.CONFIGURATION, importingVrfTableId, importingVrfTable);
LOG.info("SUBNETROUTE: addSubnetRouteFibEntryToDS: Exported route rd {} prefix {} nexthop {}"
- + " label {} to vpn {} importingRd {}", rd, prefix, nextHop, label,
+ + " label {} to vpn {} importingRd {}", rd, prefix, nextHop, label,
vpnInstance.getVpnInstanceName(), importingRd);
}
}
if (dpnId != null) {
LabelRouteInfoBuilder lriBuilder = new LabelRouteInfoBuilder();
lriBuilder.setLabel(label).setDpnId(dpnId).setPrefix(prefix).setNextHopIpList(nextHopIpList)
- .setParentVpnid(vpnId).setIsSubnetRoute(isSubnetRoute);
+ .setParentVpnid(vpnId).setIsSubnetRoute(isSubnetRoute);
if (elanTag != null) {
lriBuilder.setElanTag(elanTag);
} else {
.child(LabelRouteInfo.class, new LabelRouteInfoKey(label)).build();
tx.mergeParentStructureMerge(lriIid, lri);
LOG.info("addToLabelMapper: Added label route info to label {} prefix {} nextHopList {} vpnId {}"
- + " interface {} rd {} elantag {}", labelStr, prefix, nextHopIpList, vpnId,
+ + " interface {} rd {} elantag {}", labelStr, prefix, nextHopIpList, vpnId,
vpnInterfaceName, rd, elanTag);
} else {
LOG.warn("addToLabelMapper: Can't add entry to label map for label {} prefix {} nextHopList {}"
- + " vpnId {} interface {} rd {} elantag {}, dpnId is null", labelStr, prefix, nextHopIpList,
+ + " vpnId {} interface {} rd {} elantag {}, dpnId is null",
+ labelStr, prefix, nextHopIpList,
vpnId, vpnInterfaceName, rd, elanTag);
}
}), LOG, "addToLabelMapper");
Code Review / netvirt.git / commitdiff