*/
package org.opendaylight.netvirt.fibmanager;
+import static java.util.Objects.requireNonNull;
import static java.util.stream.Collectors.toList;
-import com.google.common.base.Optional;
-import java.math.BigInteger;
import java.util.ArrayList;
-import java.util.Collection;
import java.util.List;
+import java.util.Map;
+import java.util.Optional;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.function.Consumer;
-import javax.annotation.Nullable;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
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.eclipse.jdt.annotation.Nullable;
import org.opendaylight.genius.datastoreutils.listeners.DataTreeEventCallbackRegistrar;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
import org.opendaylight.genius.mdsalutil.actions.ActionSetFieldTunnelId;
import org.opendaylight.genius.mdsalutil.instructions.InstructionApplyActions;
import org.opendaylight.genius.utils.batching.ActionableResource;
-import org.opendaylight.genius.utils.batching.ActionableResourceImpl;
+import org.opendaylight.genius.utils.batching.ActionableResources;
import org.opendaylight.genius.utils.batching.ResourceBatchingManager;
import org.opendaylight.genius.utils.batching.ResourceHandler;
import org.opendaylight.genius.utils.batching.SubTransaction;
-import org.opendaylight.infrautils.utils.concurrent.ListenableFutures;
+import org.opendaylight.infrautils.utils.concurrent.LoggingFutures;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.netvirt.vpnmanager.api.VpnExtraRouteHelper;
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.netvirt.l3vpn.rev130911.prefix.to._interface.vpn.ids.Prefixes;
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.vpn.instance.op.data.entry.VpnToDpnList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.instance.op.data.vpn.instance.op.data.entry.VpnToDpnListKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.l3vpn.rev130911.vpn.to.extraroutes.vpn.extra.routes.Routes;
+import org.opendaylight.yangtools.concepts.Identifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.opendaylight.yangtools.yang.common.Uint64;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Singleton
-public class BgpRouteVrfEntryHandler extends BaseVrfEntryHandler
- implements ResourceHandler, IVrfEntryHandler {
+public class BgpRouteVrfEntryHandler extends BaseVrfEntryHandler implements ResourceHandler {
+ private static final class ActionableResourceIdentifier implements Identifier {
+ private static final long serialVersionUID = 1L;
+
+ private final String routeDistinguisher;
+ private final String destPrefix;
+
+ ActionableResourceIdentifier(final String routeDistinguisher, final String destPrefix) {
+ this.routeDistinguisher = requireNonNull(routeDistinguisher);
+ this.destPrefix = requireNonNull(destPrefix);
+ }
+
+ @Override
+ public int hashCode() {
+ return routeDistinguisher.hashCode() * 31 + destPrefix.hashCode();
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj) {
+ return true;
+ }
+ if (!(obj instanceof ActionableResourceIdentifier)) {
+ return false;
+ }
+ final ActionableResourceIdentifier other = (ActionableResourceIdentifier) obj;
+ return routeDistinguisher.equals(other.routeDistinguisher) && destPrefix.equals(other.destPrefix);
+ }
+
+ @Override
+ public String toString() {
+ return routeDistinguisher + destPrefix;
+ }
+ }
private static final Logger LOG = LoggerFactory.getLogger(BgpRouteVrfEntryHandler.class);
private static final int BATCH_INTERVAL = 500;
private final DataBroker dataBroker;
private final ManagedNewTransactionRunner txRunner;
- private final BlockingQueue<ActionableResource> vrfEntryBufferQ = new LinkedBlockingQueue<>();
+ private final BlockingQueue<ActionableResource<?>> vrfEntryBufferQ = new LinkedBlockingQueue<>();
private final ResourceBatchingManager resourceBatchingManager;
private final NexthopManager nexthopManager;
}
}
+ @Override
+ public void updateContainer(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
+ Object original, Object update, List<SubTransaction> transactionObjects) {
+ }
+
@Override
public void create(WriteTransaction tx, LogicalDatastoreType datastoreType, InstanceIdentifier identifier,
Object vrfEntry, List<SubTransaction> subTxns) {
}
}
- @Override
- public void createFlows(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry, String rd) {
- ActionableResource actResource = new ActionableResourceImpl(rd + vrfEntry.getDestPrefix());
- actResource.setAction(ActionableResource.CREATE);
- actResource.setInstanceIdentifier(identifier);
- actResource.setInstance(vrfEntry);
- vrfEntryBufferQ.add(actResource);
+ void createFlows(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry, String rd) {
+ vrfEntryBufferQ.add(ActionableResources.create(new ActionableResourceIdentifier(rd, vrfEntry.getDestPrefix()),
+ identifier, vrfEntry));
}
- @Override
- public void removeFlows(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry, String rd) {
- ActionableResource actResource = new ActionableResourceImpl(rd + vrfEntry.getDestPrefix());
- actResource.setAction(ActionableResource.DELETE);
- actResource.setInstanceIdentifier(identifier);
- actResource.setInstance(vrfEntry);
- vrfEntryBufferQ.add(actResource);
+ void removeFlows(InstanceIdentifier<VrfEntry> identifier, VrfEntry vrfEntry, String rd) {
+ vrfEntryBufferQ.add(ActionableResources.delete(new ActionableResourceIdentifier(rd, vrfEntry.getDestPrefix()),
+ identifier, vrfEntry));
}
- @Override
- public void updateFlows(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update, String rd) {
- ActionableResource actResource = new ActionableResourceImpl(rd + update.getDestPrefix());
- actResource.setAction(ActionableResource.UPDATE);
- actResource.setInstanceIdentifier(identifier);
- actResource.setInstance(update);
- actResource.setOldInstance(original);
- vrfEntryBufferQ.add(actResource);
+ void updateFlows(InstanceIdentifier<VrfEntry> identifier, VrfEntry original, VrfEntry update, String rd) {
+ vrfEntryBufferQ.add(ActionableResources.update(new ActionableResourceIdentifier(rd, update.getDestPrefix()),
+ identifier, update, original));
}
/*
LOG.error("Vpn Instance not availabe {}", vrfTableKey.getRouteDistinguisher());
return;
}
- final Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
- if (vpnToDpnList != null) {
- for (VpnToDpnList vpnDpn : vpnToDpnList) {
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.nonnullVpnToDpnList();
+ if (keyVpnToDpnListMap != null) {
+ for (VpnToDpnList vpnDpn : keyVpnToDpnListMap.values()) {
LOG.trace("Dpnstate is {} for dpn {} in vpn {}", vpnDpn.getDpnState(), vpnDpn.getDpnId(),
vpnInstance.getVpnId());
if (vpnDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
- createRemoteFibEntry(vpnDpn.getDpnId(), vpnInstance.getVpnId(), vrfTableKey.getRouteDistinguisher(),
- vrfEntry, writeTx, subTxns);
+ createRemoteFibEntry(vpnDpn.getDpnId(), vpnInstance.getVpnId(),
+ vrfTableKey.getRouteDistinguisher(), vrfEntry, writeTx, subTxns);
}
}
}
return;
}
String vpnName = getFibUtil().getVpnNameFromId(vpnInstance.getVpnId());
- final Collection<VpnToDpnList> vpnToDpnList = vpnInstance.getVpnToDpnList();
- if (vpnToDpnList != null) {
+ final Map<VpnToDpnListKey, VpnToDpnList> keyVpnToDpnListMap = vpnInstance.nonnullVpnToDpnList();
+ if (keyVpnToDpnListMap != null) {
List<String> usedRds = VpnExtraRouteHelper.getUsedRds(dataBroker,
vpnInstance.getVpnId(), vrfEntry.getDestPrefix());
Optional<Routes> extraRouteOptional;
usedRds.get(0), vrfEntry.getDestPrefix());
}
} else {
- extraRouteOptional = Optional.absent();
+ extraRouteOptional = Optional.empty();
}
- for (VpnToDpnList curDpn : vpnToDpnList) {
+ for (VpnToDpnList curDpn : keyVpnToDpnListMap.values()) {
if (curDpn.getDpnState() == VpnToDpnList.DpnState.Active) {
- deleteRemoteRoute(BigInteger.ZERO, curDpn.getDpnId(), vpnInstance.getVpnId(),
+ deleteRemoteRoute(Uint64.ZERO, curDpn.getDpnId(), vpnInstance.getVpnId(),
vrfTableKey, vrfEntry, extraRouteOptional, writeTx, subTxns);
}
}
}
}
- public void programRemoteFibForBgpRoutes(final BigInteger remoteDpnId,
- final long vpnId,
+ public void programRemoteFibForBgpRoutes(final Uint64 remoteDpnId,
+ final Uint32 vpnId,
final VrfEntry vrfEntry,
WriteTransaction tx,
String rd,
List<ActionInfo> actionInfos = new ArrayList<>();
for (NexthopManager.AdjacencyResult adjResult : adjacencyResults) {
String nextHopIp = adjResult.getNextHopIp();
- java.util.Optional<Long> optionalLabel = FibUtil.getLabelForNextHop(vrfEntry, nextHopIp);
+ java.util.Optional<Uint32> optionalLabel = FibUtil.getLabelForNextHop(vrfEntry, nextHopIp);
if (!optionalLabel.isPresent()) {
LOG.warn("NextHopIp {} not found in vrfEntry {}", nextHopIp, vrfEntry);
continue;
}
- long label = optionalLabel.get();
+ long label = optionalLabel.get().toJava();
actionInfos.add(new ActionRegLoad(index, FibConstants.NXM_REG_MAPPING.get(index++), 0,
31, label));
vrfEntry.getDestPrefix(), vpnId, remoteDpnId);
}
- public void createRemoteFibEntry(final BigInteger remoteDpnId,
- final long vpnId,
+ // Allow deprecated TransactionRunner calls for now
+ @SuppressWarnings("ForbidCertainMethod")
+ public void createRemoteFibEntry(final Uint64 remoteDpnId,
+ final Uint32 vpnId,
final String rd,
final VrfEntry vrfEntry,
WriteTransaction tx,
List<SubTransaction> subTxns) {
if (tx == null) {
- ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
newTx -> createRemoteFibEntry(remoteDpnId, vpnId, rd, vrfEntry, newTx, subTxns)), LOG,
"Error creating remote FIB entry");
return;
LOG.debug("Successfully added FIB entry for prefix {} in vpnId {}", vrfEntry.getDestPrefix(), vpnId);
}
- private void deleteFibEntryForBgpRoutes(BigInteger remoteDpnId, long vpnId, VrfEntry vrfEntry,
+ private void deleteFibEntryForBgpRoutes(Uint64 remoteDpnId, Uint32 vpnId, VrfEntry vrfEntry,
String rd, WriteTransaction tx, List<SubTransaction> subTxns) {
// When the tunnel is removed the fib entries should be reprogrammed/deleted depending on
// the adjacencyResults.
}
}
- public void deleteRemoteRoute(@Nullable final BigInteger localDpnId, final BigInteger remoteDpnId,
- final long vpnId, final VrfTablesKey vrfTableKey,
+ // Allow deprecated TransactionRunner calls for now
+ @SuppressWarnings("ForbidCertainMethod")
+ public void deleteRemoteRoute(@Nullable final Uint64 localDpnId, final Uint64 remoteDpnId,
+ final Uint32 vpnId, final VrfTablesKey vrfTableKey,
final VrfEntry vrfEntry, Optional<Routes> extraRouteOptional,
@Nullable WriteTransaction tx, List<SubTransaction> subTxns) {
if (tx == null) {
- ListenableFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
+ LoggingFutures.addErrorLogging(txRunner.callWithNewWriteOnlyTransactionAndSubmit(
newTx -> deleteRemoteRoute(localDpnId, remoteDpnId, vpnId, vrfTableKey, vrfEntry,
extraRouteOptional, newTx)), LOG, "Error deleting remote route");
return;
vrfEntry.getDestPrefix(), vpnId, localDpnId, remoteDpnId);
String rd = vrfTableKey.getRouteDistinguisher();
- if (localDpnId != null && !BigInteger.ZERO.equals(localDpnId)) {
+ if (localDpnId != null && !Uint64.ZERO.equals(localDpnId)) {
// localDpnId is not known when clean up happens for last vm for a vpn on a dpn
if (extraRouteOptional.isPresent()) {
nexthopManager.deleteLoadBalancingNextHop(vpnId, remoteDpnId, vrfEntry.getDestPrefix());
}
public Consumer<? super VrfEntry> getConsumerForCreatingRemoteFib(
- final BigInteger dpnId, final long vpnId, final String rd,
+ final Uint64 dpnId, final Uint32 vpnId, final String rd,
final String remoteNextHopIp, final Optional<VrfTables> vrfTable,
WriteTransaction writeCfgTxn, List<SubTransaction> subTxns) {
- return vrfEntry -> vrfEntry.nonnullRoutePaths().stream()
+ return vrfEntry -> vrfEntry.nonnullRoutePaths().values().stream()
.filter(routes -> !routes.getNexthopAddress().isEmpty()
&& remoteNextHopIp.trim().equals(routes.getNexthopAddress().trim()))
.findFirst()
}
public Consumer<? super VrfEntry> getConsumerForDeletingRemoteFib(
- final BigInteger dpnId, final long vpnId,
+ final Uint64 dpnId, final Uint32 vpnId,
final String remoteNextHopIp, final Optional<VrfTables> vrfTable,
WriteTransaction writeCfgTxn, List<SubTransaction> subTxns) {
- return vrfEntry -> vrfEntry.nonnullRoutePaths().stream()
+ return vrfEntry -> vrfEntry.nonnullRoutePaths().values().stream()
.filter(routes -> !routes.getNexthopAddress().isEmpty()
&& remoteNextHopIp.trim().equals(routes.getNexthopAddress().trim()))
.findFirst()
.ifPresent(routes -> {
LOG.trace(" deleting remote FIB entry {}", vrfEntry);
deleteRemoteRoute(null, dpnId, vpnId, vrfTable.get().key(), vrfEntry,
- Optional.absent(), writeCfgTxn, subTxns);
+ Optional.empty(), writeCfgTxn, subTxns);
});
}
@Override
- protected void addTunnelInterfaceActions(NexthopManager.AdjacencyResult adjacencyResult, long vpnId,
+ protected void addTunnelInterfaceActions(NexthopManager.AdjacencyResult adjacencyResult, Uint32 vpnId,
VrfEntry vrfEntry, List<ActionInfo> actionInfos, String rd) {
Class<? extends TunnelTypeBase> tunnelType = VpnExtraRouteHelper
.getTunnelType(getNextHopManager().getItmManager(), adjacencyResult.getInterfaceName());
}
String nextHopIp = adjacencyResult.getNextHopIp();
if (tunnelType.equals(TunnelTypeMplsOverGre.class)) {
- java.util.Optional<Long> optionalLabel = FibUtil.getLabelForNextHop(vrfEntry, nextHopIp);
+ java.util.Optional<Uint32> optionalLabel = FibUtil.getLabelForNextHop(vrfEntry, nextHopIp);
if (!optionalLabel.isPresent()) {
LOG.warn("NextHopIp {} not found in vrfEntry {}", nextHopIp, vrfEntry);
return;
}
- long label = optionalLabel.get();
+ long label = optionalLabel.get().toJava();
LOG.debug("addTunnelInterfaceActions: Push label action for prefix {} rd {} l3vni {} nextHop {}",
vrfEntry.getDestPrefix(), rd, vrfEntry.getL3vni(), nextHopIp);
actionInfos.add(new ActionPushMpls());
actionInfos.add(new ActionSetFieldMplsLabel(label));
- actionInfos.add(new ActionNxLoadInPort(BigInteger.ZERO));
+ actionInfos.add(new ActionNxLoadInPort(Uint64.ZERO));
} else if (tunnelType.equals(TunnelTypeVxlan.class)) {
- actionInfos.add(new ActionSetFieldTunnelId(BigInteger.valueOf(vrfEntry.getL3vni())));
+ actionInfos.add(new ActionSetFieldTunnelId(Uint64.valueOf(vrfEntry.getL3vni().longValue())));
LOG.debug("addTunnelInterfaceActions: adding set tunnel id action for prefix {} rd {} l3vni {}"
+ " nextHop {} ", vrfEntry.getDestPrefix(), rd, vrfEntry.getL3vni(), nextHopIp);
addRewriteDstMacAction(vpnId, vrfEntry, null /*prefixInfo*/, actionInfos);
}
@Override
- protected void addRewriteDstMacAction(long vpnId, VrfEntry vrfEntry, @Nullable Prefixes prefixInfo,
+ protected void addRewriteDstMacAction(Uint32 vpnId, VrfEntry vrfEntry, @Nullable Prefixes prefixInfo,
List<ActionInfo> actionInfos) {
if (vrfEntry.getGatewayMacAddress() != null) {
actionInfos.add(new ActionSetFieldEthernetDestination(actionInfos.size(),
Code Review / netvirt.git / blobdiff