--- /dev/null
+/*
+ * Copyright (c) 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.itm.utils;
+
+import org.eclipse.jdt.annotation.Nullable;
+import org.immutables.value.Value;
+import org.opendaylight.genius.infra.OpenDaylightImmutableStyle;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
+
+@Value.Immutable
+@OpenDaylightImmutableStyle
+public interface TunnelStateInfo {
+
+ NodeConnectorInfo getNodeConnectorInfo();
+
+ @Nullable
+ TunnelEndPointInfo getTunnelEndPointInfo();
+
+ @Nullable
+ DpnTepInterfaceInfo getDpnTepInterfaceInfo();
+
+ @Nullable
+ DPNTEPsInfo getSrcDpnTepsInfo();
+
+ @Nullable
+ DPNTEPsInfo getDstDpnTepsInfo();
+}
\ No newline at end of file
import javax.inject.Singleton;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
+import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.genius.itm.globals.ITMConstants;
+import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
+import org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorker;
+import org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorkerForNodeConnector;
+import org.opendaylight.genius.itm.utils.TunnelEndPointInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder;
import org.opendaylight.genius.mdsalutil.cache.InstanceIdDataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Caches DPNTEPsInfo objects.
@Singleton
public class DPNTEPsInfoCache extends InstanceIdDataObjectCache<DPNTEPsInfo> {
+ private static final Logger LOG = LoggerFactory.getLogger(DPNTEPsInfoCache.class);
+
+ private final DirectTunnelUtils directTunnelUtils;
+ private final JobCoordinator coordinator;
+ private final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
+ private final ManagedNewTransactionRunner txRunner;
+
@Inject
- public DPNTEPsInfoCache(DataBroker dataBroker, CacheProvider cacheProvider) {
+ public DPNTEPsInfoCache(final DataBroker dataBroker, final CacheProvider cacheProvider,
+ final DirectTunnelUtils directTunnelUtils, final JobCoordinator coordinator,
+ final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache) {
super(DPNTEPsInfo.class, dataBroker, LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(DpnEndpoints.class).child(DPNTEPsInfo.class).build(), cacheProvider);
+ this.directTunnelUtils = directTunnelUtils;
+ this.coordinator = coordinator;
+ this.unprocessedNodeConnectorEndPointCache = unprocessedNodeConnectorEndPointCache;
+ this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
+ }
+
+ @Override
+ protected void added(InstanceIdentifier<DPNTEPsInfo> path, DPNTEPsInfo dpnTepsInfo) {
+ LOG.info("DPNTepsInfo Add Received for {}", dpnTepsInfo.getDPNID());
+ String dpnId = dpnTepsInfo.getDPNID().toString();
+ directTunnelUtils.getTunnelLocks().lock(dpnId);
+ Collection<TunnelStateInfo> tunnelStateInfoList = unprocessedNodeConnectorEndPointCache.remove(dpnId);
+ directTunnelUtils.getTunnelLocks().unlock(dpnId);
+
+ if (tunnelStateInfoList != null) {
+ for (TunnelStateInfo tsInfo : tunnelStateInfoList) {
+ String interfaceName = tsInfo.getDpnTepInterfaceInfo().getTunnelName();
+ DPNTEPsInfo srcDpnTepsInfo = null;
+ DPNTEPsInfo dstDpnTepsInfo = null;
+ LOG.debug("Processing the Unprocessed NodeConnector EndPoint Cache for DPN {}", dpnTepsInfo.getDPNID());
+ TunnelEndPointInfo tunnelEndPointInfo = tsInfo.getTunnelEndPointInfo();
+ if (dpnId.equals(tunnelEndPointInfo.getSrcEndPointInfo())) {
+ srcDpnTepsInfo = dpnTepsInfo;
+ dstDpnTepsInfo = tsInfo.getDstDpnTepsInfo();
+ if (dstDpnTepsInfo == null) {
+ // Check if the destination End Point has come
+ try {
+ directTunnelUtils.getTunnelLocks().lock(tunnelEndPointInfo.getDstEndPointInfo());
+ Optional<DPNTEPsInfo> dstInfoOpt = getDPNTepFromDPNId(
+ new BigInteger(tunnelEndPointInfo.getDstEndPointInfo()));
+ if (dstInfoOpt.isPresent()) {
+ dstDpnTepsInfo = dstInfoOpt.get();
+ } else {
+ TunnelStateInfo tunnelStateInfoNew = new TunnelStateInfoBuilder()
+ .setNodeConnectorInfo(tsInfo.getNodeConnectorInfo())
+ .setDpnTepInterfaceInfo(tsInfo.getDpnTepInterfaceInfo())
+ .setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo())
+ .setSrcDpnTepsInfo(srcDpnTepsInfo).build();
+ LOG.trace("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
+ interfaceName, tunnelEndPointInfo.getDstEndPointInfo());
+ unprocessedNodeConnectorEndPointCache.add(tunnelEndPointInfo
+ .getDstEndPointInfo(), tunnelStateInfoNew);
+ }
+ } finally {
+ directTunnelUtils.getTunnelLocks().unlock(tunnelEndPointInfo.getDstEndPointInfo());
+ }
+ }
+ } else if (dpnId.equals(tunnelEndPointInfo.getDstEndPointInfo())) {
+ dstDpnTepsInfo = dpnTepsInfo;
+ srcDpnTepsInfo = tsInfo.getSrcDpnTepsInfo();
+ // Check if the destination End Point has come
+ if (srcDpnTepsInfo == null) {
+ try {
+ directTunnelUtils.getTunnelLocks().lock(tunnelEndPointInfo.getSrcEndPointInfo());
+ Optional<DPNTEPsInfo> srcInfoOpt = getDPNTepFromDPNId(
+ new BigInteger(tunnelEndPointInfo.getSrcEndPointInfo()));
+ if (srcInfoOpt.isPresent()) {
+ srcDpnTepsInfo = srcInfoOpt.get();
+ } else {
+ TunnelStateInfo tunnelStateInfoNew = new TunnelStateInfoBuilder().setNodeConnectorInfo(
+ tsInfo.getNodeConnectorInfo())
+ .setDpnTepInterfaceInfo(tsInfo.getDpnTepInterfaceInfo())
+ .setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo())
+ .setDstDpnTepsInfo(dstDpnTepsInfo).build();
+ LOG.trace("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
+ interfaceName,
+ tsInfo.getTunnelEndPointInfo().getSrcEndPointInfo());
+ unprocessedNodeConnectorEndPointCache.add(tunnelEndPointInfo.getSrcEndPointInfo(),
+ tunnelStateInfoNew);
+ }
+ } finally {
+ directTunnelUtils.getTunnelLocks().unlock(tunnelEndPointInfo.getSrcEndPointInfo());
+ }
+ }
+ }
+
+ if (srcDpnTepsInfo != null && dstDpnTepsInfo != null && directTunnelUtils.isEntityOwner()) {
+ TunnelStateInfo tunnelStateInfoNew = new TunnelStateInfoBuilder()
+ .setNodeConnectorInfo(tsInfo.getNodeConnectorInfo())
+ .setDpnTepInterfaceInfo(tsInfo.getDpnTepInterfaceInfo())
+ .setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo())
+ .setSrcDpnTepsInfo(srcDpnTepsInfo).setDstDpnTepsInfo(dstDpnTepsInfo).build();
+ LOG.debug("Queueing TunnelStateAddWorker to DJC for tunnel {}", interfaceName);
+ coordinator.enqueueJob(interfaceName,
+ new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner),
+ tunnelStateInfoNew), ITMConstants.JOB_MAX_RETRIES);
+ }
+ }
+ }
}
public List<DPNTEPsInfo> getDPNTepListFromDPNId(List<BigInteger> dpnIds) {
import static org.opendaylight.genius.itm.impl.ItmUtils.nullToEmpty;
-import com.google.common.base.Optional;
import java.math.BigInteger;
import java.util.Collection;
import java.util.Collections;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
+import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
+import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
+import org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorker;
+import org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorkerForNodeConnector;
import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo;
import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfoBuilder;
import org.opendaylight.genius.itm.utils.TunnelEndPointInfo;
import org.opendaylight.genius.itm.utils.TunnelEndPointInfoBuilder;
+import org.opendaylight.genius.itm.utils.TunnelStateInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder;
import org.opendaylight.genius.mdsalutil.cache.DataObjectCache;
import org.opendaylight.infrautils.caches.CacheProvider;
+import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBfd;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnTepsState;
private static final Logger LOG = LoggerFactory.getLogger(DpnTepStateCache.class);
private final DataBroker dataBroker;
+ private final JobCoordinator coordinator;
+ private final DirectTunnelUtils directTunnelUtils;
private final DPNTEPsInfoCache dpnTepsInfoCache;
+ private final UnprocessedNodeConnectorCache unprocessedNCCache;
+ private final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
+ private final ManagedNewTransactionRunner txRunner;
private final ConcurrentMap<String, DpnTepInterfaceInfo> dpnTepInterfaceMap = new ConcurrentHashMap<>();
private final ConcurrentMap<String, TunnelEndPointInfo> tunnelEndpointMap = new ConcurrentHashMap<>();
@Inject
- public DpnTepStateCache(DataBroker dataBroker, CacheProvider cacheProvider, DPNTEPsInfoCache dpnTepsInfoCache) {
+ public DpnTepStateCache(DataBroker dataBroker, JobCoordinator coordinator,
+ CacheProvider cacheProvider, DirectTunnelUtils directTunnelUtils,
+ DPNTEPsInfoCache dpnTepsInfoCache,
+ UnprocessedNodeConnectorCache unprocessedNCCache,
+ UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache) {
super(DpnsTeps.class, dataBroker, LogicalDatastoreType.CONFIGURATION,
InstanceIdentifier.builder(DpnTepsState.class).child(DpnsTeps.class).build(), cacheProvider,
(iid, dpnsTeps) -> dpnsTeps.getSourceDpnId(),
sourceDpnId -> InstanceIdentifier.builder(DpnTepsState.class)
.child(DpnsTeps.class, new DpnsTepsKey(sourceDpnId)).build());
this.dataBroker = dataBroker;
+ this.coordinator = coordinator;
+ this.directTunnelUtils = directTunnelUtils;
this.dpnTepsInfoCache = dpnTepsInfoCache;
+ this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
+ this.unprocessedNCCache = unprocessedNCCache;
+ this.unprocessedNodeConnectorEndPointCache = unprocessedNodeConnectorEndPointCache;
}
@Override
for (RemoteDpns remoteDpns : nullToEmpty(dpnsTeps.getRemoteDpns())) {
final String dpn = getDpnId(dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
DpnTepInterfaceInfo value = new DpnTepInterfaceInfoBuilder()
- .setTunnelName(remoteDpns.getTunnelName())
- .setIsMonitoringEnabled(remoteDpns.isMonitoringEnabled())
- .setIsInternal(remoteDpns.isInternal())
- .setTunnelType(dpnsTeps.getTunnelType()).build();
+ .setTunnelName(remoteDpns.getTunnelName())
+ .setIsMonitoringEnabled(remoteDpns.isMonitoringEnabled())
+ .setIsInternal(remoteDpns.isInternal())
+ .setTunnelType(dpnsTeps.getTunnelType()).build();
dpnTepInterfaceMap.put(dpn, value);
addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(),
dpnsTeps.getSourceDpnId().toString(), remoteDpns.getDestinationDpnId().toString());
+
+ //Process the unprocessed NodeConnector for the Tunnel, if present in the UnprocessedNodeConnectorCache
+
+ TunnelStateInfo tunnelStateInfoNew = null;
+
+ directTunnelUtils.getTunnelLocks().lock(remoteDpns.getTunnelName());
+ TunnelStateInfo tunnelStateInfo = unprocessedNCCache.remove(remoteDpns.getTunnelName());
+ directTunnelUtils.getTunnelLocks().unlock(remoteDpns.getTunnelName());
+
+ if (tunnelStateInfo != null) {
+ LOG.debug("Processing the Unprocessed NodeConnector for Tunnel {}", remoteDpns.getTunnelName());
+
+ TunnelEndPointInfo tunnelEndPtInfo = getTunnelEndPointInfo(dpnsTeps.getSourceDpnId().toString(),
+ remoteDpns.getDestinationDpnId().toString());
+ TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder()
+ .setNodeConnectorInfo(tunnelStateInfo.getNodeConnectorInfo()).setDpnTepInterfaceInfo(value)
+ .setTunnelEndPointInfo(tunnelEndPtInfo);
+
+ dpnTepsInfoCache.getDPNTepFromDPNId(dpnsTeps.getSourceDpnId()).ifPresent(builder::setSrcDpnTepsInfo);
+ dpnTepsInfoCache.getDPNTepFromDPNId(remoteDpns.getDestinationDpnId())
+ .ifPresent(builder::setDstDpnTepsInfo);
+
+ tunnelStateInfoNew = builder.build();
+ if (tunnelStateInfoNew.getSrcDpnTepsInfo() == null) {
+ String srcDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getSrcEndPointInfo();
+ directTunnelUtils.getTunnelLocks().lock(srcDpnId);
+ LOG.debug("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
+ remoteDpns.getTunnelName(), srcDpnId);
+ unprocessedNodeConnectorEndPointCache.add(srcDpnId, tunnelStateInfoNew);
+ directTunnelUtils.getTunnelLocks().unlock(srcDpnId);
+ }
+
+ if (tunnelStateInfoNew.getDstDpnTepsInfo() == null) {
+ String dstDpnId = tunnelStateInfo.getTunnelEndPointInfo().getDstEndPointInfo();
+ directTunnelUtils.getTunnelLocks().lock(dstDpnId);
+ LOG.debug("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
+ remoteDpns.getTunnelName(), dstDpnId);
+ unprocessedNodeConnectorEndPointCache.add(dstDpnId, tunnelStateInfoNew);
+ directTunnelUtils.getTunnelLocks().unlock(dstDpnId);
+ }
+ }
+
+ if (tunnelStateInfoNew != null && tunnelStateInfoNew.getSrcDpnTepsInfo() != null
+ && tunnelStateInfoNew.getDstDpnTepsInfo() != null && directTunnelUtils.isEntityOwner()) {
+ TunnelStateAddWorkerForNodeConnector ifStateAddWorker =
+ new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner),
+ tunnelStateInfoNew);
+ coordinator.enqueueJob(remoteDpns.getTunnelName(), ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
+ }
}
}
DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId));
if (dpnTepInterfaceInfo == null) {
try {
- Optional<DpnsTeps> dpnsTeps = super.get(srcDpnId);
+ com.google.common.base.Optional<DpnsTeps> dpnsTeps = super.get(srcDpnId);
if (dpnsTeps.isPresent()) {
DpnsTeps teps = dpnsTeps.get();
nullToEmpty(teps.getRemoteDpns()).forEach(remoteDpns -> {
//Start: TunnelEndPoint Cache accessors
private void addTunnelEndPointInfoToCache(String tunnelName, String srcEndPtInfo, String dstEndPtInfo) {
- TunnelEndPointInfo tunnelEndPointInfo = new TunnelEndPointInfoBuilder().setSrcEndPointInfo(srcEndPtInfo)
- .setDstEndPointInfo(dstEndPtInfo).build();
- tunnelEndpointMap.put(tunnelName, tunnelEndPointInfo);
+ tunnelEndpointMap.put(tunnelName, getTunnelEndPointInfo(srcEndPtInfo,dstEndPtInfo));
+ }
+
+ private TunnelEndPointInfo getTunnelEndPointInfo(String srcEndPtInfo, String dstEndPtInfo) {
+ return
+ new TunnelEndPointInfoBuilder().setSrcEndPointInfo(srcEndPtInfo).setDstEndPointInfo(dstEndPtInfo).build();
}
public TunnelEndPointInfo getTunnelEndPointInfoFromCache(String tunnelName) {
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.inject.Singleton;
-import org.opendaylight.genius.itm.utils.NodeConnectorInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfo;
@Singleton
public class UnprocessedNodeConnectorCache {
- private final ConcurrentMap<String, NodeConnectorInfo> unprocessedNodeConnectorMap = new ConcurrentHashMap<>();
+ private final ConcurrentMap<String, TunnelStateInfo> unprocessedNodeConnectorMap = new ConcurrentHashMap<>();
- public void add(String tunnelName, NodeConnectorInfo ncInfo) {
- unprocessedNodeConnectorMap.put(tunnelName, ncInfo);
+ public void add(String tunnelName, TunnelStateInfo tunnelStateInfo) {
+ unprocessedNodeConnectorMap.put(tunnelName, tunnelStateInfo);
}
- public NodeConnectorInfo get(String tunnelName) {
+ public TunnelStateInfo get(String tunnelName) {
return unprocessedNodeConnectorMap.get(tunnelName);
}
- public NodeConnectorInfo remove(String tunnelName) {
+ public TunnelStateInfo remove(String tunnelName) {
return unprocessedNodeConnectorMap.remove(tunnelName);
}
}
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.inject.Singleton;
-import org.opendaylight.genius.itm.utils.NodeConnectorInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(UnprocessedNodeConnectorEndPointCache.class);
- private final ConcurrentMap<String, Set<NodeConnectorInfo>> unProcessedNodeConnectorEndPtMap =
+ private final ConcurrentMap<String, Set<TunnelStateInfo>> unProcessedNodeConnectorEndPtMap =
new ConcurrentHashMap<>();
- public void add(String dpnId, Collection<NodeConnectorInfo> ncList) {
+ public void add(String dpnId, Collection<TunnelStateInfo> ncList) {
unProcessedNodeConnectorEndPtMap.computeIfAbsent(dpnId, key -> ConcurrentHashMap.newKeySet()).addAll(ncList);
}
- public void add(String dpnId, NodeConnectorInfo ncInfo) {
- unProcessedNodeConnectorEndPtMap.computeIfAbsent(dpnId, key -> ConcurrentHashMap.newKeySet()).add(ncInfo);
+ public void add(String dpnId, TunnelStateInfo tunnelStateInfo) {
+ unProcessedNodeConnectorEndPtMap.computeIfAbsent(dpnId, key -> ConcurrentHashMap.newKeySet())
+ .add(tunnelStateInfo);
}
- public void remove(String dpnId) {
- unProcessedNodeConnectorEndPtMap.remove(dpnId);
+ public Collection<TunnelStateInfo> remove(String dpnId) {
+ return unProcessedNodeConnectorEndPtMap.remove(dpnId);
}
- public void remove(String dpnId, NodeConnectorInfo ncInfo) {
- Collection<NodeConnectorInfo> ncList = get(dpnId);
- if (ncList != null) {
- ncList.remove(ncInfo);
+ public void remove(String dpnId, TunnelStateInfo ncInfo) {
+ Collection<TunnelStateInfo> tunnelStateInfoList = get(dpnId);
+ if (tunnelStateInfoList != null) {
+ tunnelStateInfoList.remove(ncInfo);
} else {
- LOG.debug("NodeConnectorInfo List for DPN Id {} is null", dpnId);
+ LOG.debug("TunnelStateInfo List for DPN Id {} is null", dpnId);
}
}
- public Collection<NodeConnectorInfo> get(String dpnId) {
+ public Collection<TunnelStateInfo> get(String dpnId) {
return unProcessedNodeConnectorEndPtMap.get(dpnId);
}
}
+++ /dev/null
-/*
- * Copyright (c) 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.genius.itm.itmdirecttunnels.listeners;
-
-import static org.opendaylight.genius.infra.Datastore.CONFIGURATION;
-
-import com.google.common.util.concurrent.ListenableFuture;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.infra.Datastore;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
-import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.infra.TypedWriteTransaction;
-import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
-import org.opendaylight.genius.itm.cache.DpnTepStateCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
-import org.opendaylight.genius.itm.globals.ITMConstants;
-import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
-import org.opendaylight.genius.itm.impl.ItmUtils;
-import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
-import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo;
-import org.opendaylight.genius.itm.utils.NodeConnectorInfo;
-import org.opendaylight.genius.itm.utils.NodeConnectorInfoBuilder;
-import org.opendaylight.genius.itm.utils.TunnelEndPointInfo;
-import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
-import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.IfIndexesTunnelMap;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnel;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnelBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnelKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.state.tunnel.list.DstInfoBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.state.tunnel.list.SrcInfoBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
-import org.opendaylight.yangtools.yang.binding.DataObject;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.OperationFailedException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-abstract class AbstractTunnelListenerBase<T extends DataObject> extends AbstractClusteredSyncDataTreeChangeListener<T> {
-
- private static final Logger LOG = LoggerFactory.getLogger(AbstractTunnelListenerBase.class);
-
- protected final DpnTepStateCache dpnTepStateCache;
- protected final DPNTEPsInfoCache dpntePsInfoCache;
- protected final UnprocessedNodeConnectorCache unprocessedNCCache;
- protected final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
- protected final DirectTunnelUtils directTunnelUtils;
- protected final ManagedNewTransactionRunner txRunner;
-
- private final EntityOwnershipUtils entityOwnershipUtils;
-
- AbstractTunnelListenerBase(final DataBroker dataBroker,
- final LogicalDatastoreType logicalDatastoreType,
- final InstanceIdentifier<T> instanceIdentifier,
- final DpnTepStateCache dpnTepStateCache,
- final DPNTEPsInfoCache dpntePsInfoCache,
- final UnprocessedNodeConnectorCache unprocessedNodeConnectorCache,
- final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache,
- final EntityOwnershipUtils entityOwnershipUtils,
- final DirectTunnelUtils directTunnelUtils) {
- super(dataBroker, logicalDatastoreType, instanceIdentifier);
- this.dpnTepStateCache = dpnTepStateCache;
- this.dpntePsInfoCache = dpntePsInfoCache;
- this.unprocessedNCCache = unprocessedNodeConnectorCache;
- this.unprocessedNodeConnectorEndPointCache = unprocessedNodeConnectorEndPointCache;
- this.entityOwnershipUtils = entityOwnershipUtils;
- this.directTunnelUtils = directTunnelUtils;
- this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
- }
-
- public boolean entityOwner() {
- return entityOwnershipUtils.isEntityOwner(ITMConstants.ITM_CONFIG_ENTITY, ITMConstants.ITM_CONFIG_ENTITY);
- }
-
- public List<ListenableFuture<Void>> addState(InstanceIdentifier<FlowCapableNodeConnector> key,
- String interfaceName, FlowCapableNodeConnector fcNodeConnectorNew)
- throws ExecutionException, InterruptedException, OperationFailedException {
- NodeConnectorInfo nodeConnectorInfo = new NodeConnectorInfoBuilder().setNodeConnectorId(key)
- .setNodeConnector(fcNodeConnectorNew).build();
- // Retrieve Port No from nodeConnectorId
- NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
- long portNo = DirectTunnelUtils.getPortNumberFromNodeConnectorId(nodeConnectorId);
- if (portNo == ITMConstants.INVALID_PORT_NO) {
- LOG.error("Cannot derive port number, not proceeding with Interface State "
- + "addition for interface: {}", interfaceName);
- return Collections.emptyList();
- }
-
- LOG.info("adding interface state to Oper DS for interface: {}", interfaceName);
-
- Interface.OperStatus operStatus = Interface.OperStatus.Up;
- Interface.AdminStatus adminStatus = Interface.AdminStatus.Up;
-
- TunnelEndPointInfo tunnelEndPointInfo;
- DpnTepInterfaceInfo dpnTepConfigInfo = null;
- List<ListenableFuture<Void>> futures = new ArrayList<>();
-
- // Fetch the interface/Tunnel from config DS if exists
- // If it doesnt exists then "park" the processing and comeback to it when the data is available and
- // this will be triggered by the corres. listener. Caching and de-caching has to be synchronized.
- try {
- directTunnelUtils.getTunnelLocks().lock(interfaceName);
- tunnelEndPointInfo = dpnTepStateCache.getTunnelEndPointInfoFromCache(interfaceName);
-
- if (tunnelEndPointInfo != null) {
- BigInteger srcDpnId = new BigInteger(tunnelEndPointInfo.getSrcEndPointInfo());
- BigInteger dpnId = DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId);
- if (srcDpnId.compareTo(dpnId) != 0) {
- //This is a preventive measure to check if the node connector is coming from the switch
- // to which the tunnel was pushed. If it came from wrong switch due to duplicate tunnel
- // then drop the node connector event.
- LOG.error("The Source DPN ID {} from ITM Config does not match with the DPN ID {},"
- + "fetched from NodeConnector Add event. Returning here.",
- srcDpnId, dpnId);
- return Collections.emptyList();
- }
- dpnTepConfigInfo = dpnTepStateCache.getDpnTepInterface(
- new BigInteger(tunnelEndPointInfo.getSrcEndPointInfo()),
- new BigInteger(tunnelEndPointInfo.getDstEndPointInfo()));
- }
- if (tunnelEndPointInfo == null || dpnTepConfigInfo == null) {
- LOG.info("Unable to process the NodeConnector ADD event for {} as Config not available."
- + "Hence parking it", interfaceName);
- unprocessedNCCache.add(interfaceName, nodeConnectorInfo);
- return Collections.emptyList();
- }
- } finally {
- directTunnelUtils.getTunnelLocks().unlock(interfaceName);
- }
- StateTunnelList stateTnl = addStateEntry(tunnelEndPointInfo, interfaceName,
- operStatus, adminStatus, nodeConnectorInfo);
-
- // This will be only tunnel If so not required
- // If this interface is a tunnel interface, create the tunnel ingress flow,
- // and start tunnel monitoring
- if (stateTnl != null) {
- futures.add(txRunner.callWithNewWriteOnlyTransactionAndSubmit(CONFIGURATION,
- tx -> handleTunnelMonitoringAddition(tx, nodeConnectorId, stateTnl.getIfIndex(), interfaceName,
- portNo)));
- }
- return futures;
- }
-
- private StateTunnelList addStateEntry(TunnelEndPointInfo tunnelEndPointInfo, String interfaceName,
- Interface.OperStatus operStatus, Interface.AdminStatus adminStatus,
- NodeConnectorInfo nodeConnectorInfo)
- throws ExecutionException, InterruptedException, OperationFailedException {
- LOG.debug("Start addStateEntry adding interface state for {}", interfaceName);
- final StateTunnelListBuilder stlBuilder = new StateTunnelListBuilder();
- Class<? extends TunnelTypeBase> tunnelType;
- java.util.Optional<DPNTEPsInfo> srcDpnTepsInfo;
- java.util.Optional<DPNTEPsInfo> dstDpnTePsInfo;
-
- // Retrieve Port No from nodeConnectorId
- InstanceIdentifier<FlowCapableNodeConnector> key = nodeConnectorInfo.getNodeConnectorId();
- NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
-
- final long portNo = DirectTunnelUtils.getPortNumberFromNodeConnectorId(nodeConnectorId);
- DpnTepInterfaceInfo dpnTepInfo = dpnTepStateCache.getDpnTepInterface(
- new BigInteger(tunnelEndPointInfo.getSrcEndPointInfo()),
- new BigInteger(tunnelEndPointInfo.getDstEndPointInfo()));
- LOG.debug("Source Dpn TEP Interface Info {}", dpnTepInfo);
- tunnelType = dpnTepInfo.getTunnelType();
-
- try {
- directTunnelUtils.getTunnelLocks().lock(tunnelEndPointInfo.getSrcEndPointInfo());
- srcDpnTepsInfo = dpntePsInfoCache
- .getDPNTepFromDPNId(new BigInteger(tunnelEndPointInfo.getSrcEndPointInfo()));
- if (!srcDpnTepsInfo.isPresent()) {
- LOG.info("Unable to add State for tunnel {}. Hence Parking with key {}",
- interfaceName, tunnelEndPointInfo.getSrcEndPointInfo());
- unprocessedNodeConnectorEndPointCache.add(tunnelEndPointInfo.getSrcEndPointInfo(), nodeConnectorInfo);
- }
- } finally {
- directTunnelUtils.getTunnelLocks().unlock(tunnelEndPointInfo.getSrcEndPointInfo());
- }
-
- try {
- directTunnelUtils.getTunnelLocks().lock(tunnelEndPointInfo.getDstEndPointInfo());
- dstDpnTePsInfo = dpntePsInfoCache
- .getDPNTepFromDPNId(new BigInteger(tunnelEndPointInfo.getDstEndPointInfo()));
- if (!dstDpnTePsInfo.isPresent()) {
- LOG.info("Unable to add State for tunnel {}. Hence Parking with key {}",
- interfaceName, tunnelEndPointInfo.getDstEndPointInfo());
- unprocessedNodeConnectorEndPointCache.add(tunnelEndPointInfo.getDstEndPointInfo(), nodeConnectorInfo);
- }
- } finally {
- directTunnelUtils.getTunnelLocks().unlock(tunnelEndPointInfo.getDstEndPointInfo());
- }
-
- if (!(srcDpnTepsInfo.isPresent() && dstDpnTePsInfo.isPresent())) {
- return null;
- }
- // Now do the entity owner check as all data to process the event is available
- if (!entityOwner()) {
- return null;
- }
-
- final SrcInfoBuilder srcInfoBuilder =
- new SrcInfoBuilder().setTepDeviceId(tunnelEndPointInfo.getSrcEndPointInfo());
- final DstInfoBuilder dstInfoBuilder =
- new DstInfoBuilder().setTepDeviceId(tunnelEndPointInfo.getDstEndPointInfo());
- LOG.debug("Source Dpn TEP Info {}", srcDpnTepsInfo);
- TunnelEndPoints srcEndPtInfo = srcDpnTepsInfo.get().getTunnelEndPoints().get(0);
- srcInfoBuilder.setTepIp(srcEndPtInfo.getIpAddress());
- // As ITM Direct Tunnels deals with only Internal Tunnels.
- // Relook at this when it deals with external as well
- srcInfoBuilder.setTepDeviceType(TepTypeInternal.class);
-
- LOG.debug("Dest Dpn TEP Info {}", dstDpnTePsInfo);
- TunnelEndPoints dstEndPtInfo = dstDpnTePsInfo.get().getTunnelEndPoints().get(0);
- dstInfoBuilder.setTepIp(dstEndPtInfo.getIpAddress());
- // As ITM Direct Tunnels deals with only Internal Tunnels.
- // Relook at this when it deals with external as well
- dstInfoBuilder.setTepDeviceType(TepTypeInternal.class);
-
- // ITM Direct Tunnels NOT SETTING THE TEP TYPe coz its not available. CHECK IF REQUIRED
- TunnelOperStatus tunnelOperStatus = DirectTunnelUtils.convertInterfaceToTunnelOperState(operStatus);
- boolean tunnelState = operStatus.equals(Interface.OperStatus.Up);
-
- StateTunnelListKey tlKey = new StateTunnelListKey(interfaceName);
- stlBuilder.withKey(tlKey)
- .setOperState(tunnelOperStatus).setTunnelState(tunnelState)
- .setDstInfo(dstInfoBuilder.build()).setSrcInfo(srcInfoBuilder.build()).setTransportType(tunnelType)
- .setPortNumber(String.valueOf(portNo));
- int ifIndex;
- ifIndex = directTunnelUtils.allocateId(ITMConstants.ITM_IDPOOL_NAME, interfaceName);
- createLportTagInterfaceMap(interfaceName, ifIndex);
- stlBuilder.setIfIndex(ifIndex);
- InstanceIdentifier<StateTunnelList> stListId = ItmUtils.buildStateTunnelListId(tlKey);
- LOG.trace("Batching the Creation of tunnel_state: {} for Id: {}", stlBuilder.build(), stListId);
- ITMBatchingUtils.write(stListId, stlBuilder.build(), ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
- return stlBuilder.build();
- }
-
- private void handleTunnelMonitoringAddition(TypedWriteTransaction<Datastore.Configuration> tx,
- NodeConnectorId nodeConnectorId, Integer ifindex, String interfaceName, long portNo) {
- BigInteger dpId = DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId);
- directTunnelUtils.addTunnelIngressFlow(tx, dpId, portNo, interfaceName,
- ifindex);
- }
-
- private void createLportTagInterfaceMap(String infName, Integer ifIndex) {
- LOG.debug("creating lport tag to interface map for {}", infName);
- InstanceIdentifier<IfIndexTunnel> id = InstanceIdentifier.builder(IfIndexesTunnelMap.class)
- .child(IfIndexTunnel.class, new IfIndexTunnelKey(ifIndex)).build();
- IfIndexTunnel ifIndexInterface = new IfIndexTunnelBuilder().setIfIndex(ifIndex)
- .withKey(new IfIndexTunnelKey(ifIndex)).setInterfaceName(infName).build();
- ITMBatchingUtils.write(id, ifIndexInterface, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
- }
-
- protected class InterfaceStateAddWorkerForUnprocessedNC implements Callable<List<ListenableFuture<Void>>> {
- private final InstanceIdentifier<FlowCapableNodeConnector> key;
- private final FlowCapableNodeConnector fcNodeConnectorNew;
- private final String interfaceName;
-
- InterfaceStateAddWorkerForUnprocessedNC(InstanceIdentifier<FlowCapableNodeConnector> key,
- FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
- this.key = key;
- this.fcNodeConnectorNew = fcNodeConnectorNew;
- this.interfaceName = portName;
- }
-
- @Override
- public List<ListenableFuture<Void>> call() throws Exception {
- // If another renderer(for eg : OVS) needs to be supported, check can be performed here
- // to call the respective helpers.
- return addState(key, interfaceName, fcNodeConnectorNew);
- }
-
- @Override
- public String toString() {
- return "InterfaceStateAddWorkerForUnprocessedNC{"
- + "fcNodeConnectorIdentifier=" + key
- + ", fcNodeConnectorNew=" + fcNodeConnectorNew
- + ", interfaceName='" + interfaceName + '\''
- + '}';
- }
- }
-}
\ No newline at end of file
+++ /dev/null
-/*
- * Copyright (c) 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.genius.itm.itmdirecttunnels.listeners;
-
-import static org.opendaylight.genius.itm.impl.ItmUtils.nullToEmpty;
-
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
-import org.opendaylight.genius.itm.cache.DpnTepStateCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
-import org.opendaylight.genius.itm.globals.ITMConstants;
-import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
-import org.opendaylight.genius.itm.utils.NodeConnectorInfo;
-import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
-import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnTepsState;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.DpnsTeps;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class DpnTepStateListener extends AbstractTunnelListenerBase<DpnsTeps> {
-
- private static final Logger LOG = LoggerFactory.getLogger(DpnTepStateListener.class);
-
- private final JobCoordinator coordinator;
-
- public DpnTepStateListener(final DataBroker dataBroker,
- final JobCoordinator coordinator,
- final EntityOwnershipUtils entityOwnershipUtils,
- final DpnTepStateCache dpnTepStateCache,
- final DPNTEPsInfoCache dpntePsInfoCache,
- final UnprocessedNodeConnectorCache unprocessedNodeConnectorCache,
- final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache,
- final DirectTunnelUtils directTunnelUtils) {
- super(dataBroker, LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.create(DpnTepsState.class).child(DpnsTeps.class),
- dpnTepStateCache, dpntePsInfoCache, unprocessedNodeConnectorCache,
- unprocessedNodeConnectorEndPointCache, entityOwnershipUtils,
- directTunnelUtils);
- this.coordinator = coordinator;
- super.register();
- }
-
- @Override
- public void add(@Nonnull InstanceIdentifier<DpnsTeps> instanceIdentifier, @Nonnull DpnsTeps dpnsTeps) {
- if (!entityOwner()) {
- return;
- }
- for (RemoteDpns remoteDpns : nullToEmpty(dpnsTeps.getRemoteDpns())) {
- //Process the unprocessed NodeConnector for the Tunnel, if present in the UnprocessedNodeConnectorCache
- // This may run in all node as its ClusteredDTCN but cache will be populated in only the Entity owner
- String tunnelName = remoteDpns.getTunnelName();
- try {
- directTunnelUtils.getTunnelLocks().lock(tunnelName);
- NodeConnectorInfo nodeConnectorInfo = unprocessedNCCache.remove(tunnelName);
- if (nodeConnectorInfo != null) {
- LOG.info("Processing the Unprocessed NodeConnector for Tunnel {}", tunnelName);
- // Queue the IntefaceAddWorkerForUnprocessNC in DJC
- String portName = nodeConnectorInfo.getNodeConnector().getName();
- InterfaceStateAddWorkerForUnprocessedNC ifStateAddWorker =
- new InterfaceStateAddWorkerForUnprocessedNC(nodeConnectorInfo.getNodeConnectorId(),
- nodeConnectorInfo.getNodeConnector(), portName);
- coordinator.enqueueJob(portName, ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
- }
- } finally {
- directTunnelUtils.getTunnelLocks().unlock(tunnelName);
- }
- }
- }
-}
+++ /dev/null
-/*
- * Copyright (c) 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.genius.itm.itmdirecttunnels.listeners;
-
-import java.util.Collection;
-import javax.annotation.Nonnull;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
-import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
-import org.opendaylight.genius.itm.cache.DpnTepStateCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
-import org.opendaylight.genius.itm.globals.ITMConstants;
-import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
-import org.opendaylight.genius.itm.utils.NodeConnectorInfo;
-import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
-import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public class DpnTepsInfoListener extends AbstractTunnelListenerBase<DPNTEPsInfo> {
-
- private static final Logger LOG = LoggerFactory.getLogger(DpnTepsInfoListener.class);
-
- private final JobCoordinator coordinator;
- private final IInterfaceManager interfaceManager;
-
- public DpnTepsInfoListener(final DataBroker dataBroker,
- final JobCoordinator coordinator,
- final EntityOwnershipUtils entityOwnershipUtils,
- final DpnTepStateCache dpnTepStateCache,
- final DPNTEPsInfoCache dpntePsInfoCache,
- final UnprocessedNodeConnectorCache unprocessedNodeConnectorCache,
- final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache,
- final IInterfaceManager interfaceManager,
- final DirectTunnelUtils directTunnelUtils) {
- super(dataBroker, LogicalDatastoreType.CONFIGURATION,
- InstanceIdentifier.create(DpnEndpoints.class).child(DPNTEPsInfo.class),
- dpnTepStateCache, dpntePsInfoCache, unprocessedNodeConnectorCache,
- unprocessedNodeConnectorEndPointCache, entityOwnershipUtils,
- directTunnelUtils);
- this.coordinator = coordinator;
- this.interfaceManager = interfaceManager;
- super.register();
- }
-
- @Override
- public void add(@Nonnull InstanceIdentifier<DPNTEPsInfo> instanceIdentifier, @Nonnull DPNTEPsInfo dpnTepsInfo) {
- LOG.trace("DPN Teps Info Add {}", dpnTepsInfo);
- if (interfaceManager.isItmDirectTunnelsEnabled()) {
- //Process the unprocessed NodeConnector for the Tunnel, if present in the UnprocessedNodeConnectorEndPtCache
- // This may run in all node as its ClusteredDTCN but cache will be populated in only the Entity owner
- String dpnId = dpnTepsInfo.getDPNID().toString();
- try {
- directTunnelUtils.getTunnelLocks().lock(dpnId);
- Collection<NodeConnectorInfo> nodeConnectorInfoList = unprocessedNodeConnectorEndPointCache.get(dpnId);
- if (nodeConnectorInfoList != null) {
- for (NodeConnectorInfo ncInfo : nodeConnectorInfoList) {
- LOG.info("Processing the Unprocessed NodeConnector for Tunnel {}", ncInfo
- .getNodeConnector().getName());
- // Queue the InterfaceStateAddWorker in DJC
-
- String portName = ncInfo.getNodeConnector().getName();
- InterfaceStateAddWorkerForUnprocessedNC ifStateAddWorker =
- new InterfaceStateAddWorkerForUnprocessedNC(ncInfo.getNodeConnectorId(),
- ncInfo.getNodeConnector(), portName);
- coordinator.enqueueJob(portName, ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
- // Remove the NodeConnector Entry from UnprocessedNodeConnectorEndPt Map
- unprocessedNodeConnectorEndPointCache.remove(dpnId, ncInfo);
- }
- }
- } finally {
- directTunnelUtils.getTunnelLocks().unlock(dpnId);
- }
- }
- }
-}
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.impl.ItmUtils;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
+import org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorker;
+import org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorkerForNodeConnector;
import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo;
import org.opendaylight.genius.itm.utils.NodeConnectorInfo;
import org.opendaylight.genius.itm.utils.NodeConnectorInfoBuilder;
-import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
+import org.opendaylight.genius.itm.utils.TunnelEndPointInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
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.FlowCapableNodeConnector;
* This Class is a Data Change Listener for FlowCapableNodeConnector updates.
* This creates an entry in the tunnels-state OperDS for every node-connector used.
*/
-public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<FlowCapableNodeConnector> {
+public class TunnelInventoryStateListener extends
+ AbstractClusteredSyncDataTreeChangeListener<FlowCapableNodeConnector> {
private static final Logger LOG = LoggerFactory.getLogger(TunnelInventoryStateListener.class);
private final JobCoordinator coordinator;
private final ManagedNewTransactionRunner txRunner;
private final TunnelStateCache tunnelStateCache;
+ private final DpnTepStateCache dpnTepStateCache;
+ private final DPNTEPsInfoCache dpntePsInfoCache;
+ private final UnprocessedNodeConnectorCache unprocessedNCCache;
+ private final UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
+ private final DirectTunnelUtils directTunnelUtils;
public TunnelInventoryStateListener(final DataBroker dataBroker,
final JobCoordinator coordinator,
- final EntityOwnershipUtils entityOwnershipUtils,
final TunnelStateCache tunnelStateCache,
final DpnTepStateCache dpnTepStateCache,
final DPNTEPsInfoCache dpntePsInfoCache,
final UnprocessedNodeConnectorCache unprocessedNCCache,
final UnprocessedNodeConnectorEndPointCache
- unprocessedNodeConnectorEndPointCache,
+ unprocessedNodeConnectorEndPointCache,
final DirectTunnelUtils directTunnelUtils) {
super(dataBroker, LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Nodes.class).child(Node.class)
- .child(NodeConnector.class).augmentation(FlowCapableNodeConnector.class), dpnTepStateCache,
- dpntePsInfoCache, unprocessedNCCache,
- unprocessedNodeConnectorEndPointCache, entityOwnershipUtils, directTunnelUtils);
+ .child(NodeConnector.class).augmentation(FlowCapableNodeConnector.class));
this.coordinator = coordinator;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.tunnelStateCache = tunnelStateCache;
+ this.dpnTepStateCache = dpnTepStateCache;
+ this.dpntePsInfoCache = dpntePsInfoCache;
+ this.unprocessedNCCache = unprocessedNCCache;
+ this.unprocessedNodeConnectorEndPointCache = unprocessedNodeConnectorEndPointCache;
+ this.directTunnelUtils = directTunnelUtils;
super.register();
}
return;
}
}
- if (!entityOwner()) {
+ if (!directTunnelUtils.isEntityOwner()) {
return;
}
LOG.debug("Received NodeConnector Remove Event: {}, {}", key, flowCapableNodeConnector);
LOG.debug("Node Connector Update {} Interface is not a internal tunnel I/f, so no-op", portName);
return;
}
- if (fcNodeConnectorNew.getReason() == PortReason.Delete || !entityOwner()) {
+ if (fcNodeConnectorNew.getReason() == PortReason.Delete || !directTunnelUtils.isEntityOwner()) {
return;
}
LOG.debug("Received NodeConnector Update Event: {}, {}, {}", key, fcNodeConnectorOld, fcNodeConnectorNew);
@Override
public void add(@Nonnull InstanceIdentifier<FlowCapableNodeConnector> key,
@Nonnull FlowCapableNodeConnector fcNodeConnectorNew) {
+ LOG.info("Received NodeConnector Add Event: {}, {}", key, fcNodeConnectorNew);
String portName = fcNodeConnectorNew.getName();
- LOG.debug("InterfaceInventoryState ADD for {}", portName);
// Return if its not tunnel port and if its not Internal
if (!DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName)) {
LOG.debug("Node Connector Add {} Interface is not a tunnel I/f, so no-op", portName);
return;
}
- if (!dpnTepStateCache.isConfigAvailable(portName)) {
- // Park the notification
- LOG.debug("Unable to process the NodeConnector ADD event for {} as Config not available."
+ NodeConnectorInfo nodeConnectorInfo =
+ new NodeConnectorInfoBuilder().setNodeConnectorId(key).setNodeConnector(fcNodeConnectorNew).build();
+ TunnelStateInfo tunnelStateInfo = null;
+ TunnelEndPointInfo tunnelEndPtInfo = null;
+ try {
+ directTunnelUtils.getTunnelLocks().lock(portName);
+ if (!dpnTepStateCache.isConfigAvailable(portName)) {
+ // Park the notification
+ LOG.debug("Unable to process the NodeConnector ADD event for {} as Config not available."
+ "Hence parking it", portName);
- NodeConnectorInfo nodeConnectorInfo = new NodeConnectorInfoBuilder().setNodeConnectorId(key)
- .setNodeConnector(fcNodeConnectorNew).build();
- unprocessedNCCache.add(portName, nodeConnectorInfo);
- return;
- } else if (!dpnTepStateCache.isInternal(portName)) {
- LOG.debug("{} Interface is not a internal tunnel I/f, so no-op", portName);
- return;
+ unprocessedNCCache.add(portName,
+ new TunnelStateInfoBuilder().setNodeConnectorInfo(nodeConnectorInfo).build());
+ return;
+ } else if (!dpnTepStateCache.isInternal(portName)) {
+ LOG.debug("{} Interface is not a internal tunnel I/f, so no-op", portName);
+ return;
+ }
+ } finally {
+ directTunnelUtils.getTunnelLocks().unlock(portName);
}
- LOG.debug("Received NodeConnector Add Event: {}, {}", key, fcNodeConnectorNew);
- // NodeConnectorId nodeConnectorId =
- // InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
- TunnelInterfaceStateAddWorker ifStateAddWorker =
- new TunnelInterfaceStateAddWorker(key, fcNodeConnectorNew, portName);
- coordinator.enqueueJob(portName, ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
+ if (DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && dpnTepStateCache.isInternal(portName)) {
+ tunnelEndPtInfo = dpnTepStateCache.getTunnelEndPointInfoFromCache(portName);
+ TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder().setNodeConnectorInfo(nodeConnectorInfo);
+ dpntePsInfoCache.getDPNTepFromDPNId(new BigInteger(tunnelEndPtInfo.getSrcEndPointInfo()))
+ .ifPresent(builder::setSrcDpnTepsInfo);
+ dpntePsInfoCache.getDPNTepFromDPNId(new BigInteger(tunnelEndPtInfo.getDstEndPointInfo()))
+ .ifPresent(builder::setDstDpnTepsInfo);
+ tunnelStateInfo = builder.setTunnelEndPointInfo(tunnelEndPtInfo)
+ .setDpnTepInterfaceInfo(dpnTepStateCache.getTunnelFromCache(portName)).build();
+ if (tunnelStateInfo.getSrcDpnTepsInfo() == null) {
+ directTunnelUtils.getTunnelLocks().lock(tunnelEndPtInfo.getSrcEndPointInfo());
+ LOG.debug("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
+ portName, tunnelEndPtInfo.getSrcEndPointInfo());
+ unprocessedNodeConnectorEndPointCache.add(tunnelEndPtInfo.getSrcEndPointInfo(), tunnelStateInfo);
+ directTunnelUtils.getTunnelLocks().unlock(tunnelEndPtInfo.getSrcEndPointInfo());
+ }
+ if (tunnelStateInfo.getDstDpnTepsInfo() == null) {
+ directTunnelUtils.getTunnelLocks().lock(tunnelEndPtInfo.getDstEndPointInfo());
+ LOG.debug("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}",
+ portName, tunnelEndPtInfo.getDstEndPointInfo());
+ unprocessedNodeConnectorEndPointCache.add(tunnelEndPtInfo.getDstEndPointInfo(), tunnelStateInfo);
+ directTunnelUtils.getTunnelLocks().unlock(tunnelEndPtInfo.getDstEndPointInfo());
+ }
+ }
+
+ if (tunnelEndPtInfo != null && tunnelStateInfo.getSrcDpnTepsInfo() != null
+ && tunnelStateInfo.getDstDpnTepsInfo() != null && directTunnelUtils.isEntityOwner()) {
+ coordinator.enqueueJob(portName,
+ new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner),
+ tunnelStateInfo), ITMConstants.JOB_MAX_RETRIES);
+ }
}
private List<ListenableFuture<Void>> updateState(String interfaceName,
return futures;
}
- private class TunnelInterfaceStateAddWorker implements Callable {
- private final InstanceIdentifier<FlowCapableNodeConnector> key;
- private final FlowCapableNodeConnector fcNodeConnectorNew;
- private final String interfaceName;
-
- TunnelInterfaceStateAddWorker(InstanceIdentifier<FlowCapableNodeConnector> key,
- FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
- this.key = key;
- this.fcNodeConnectorNew = fcNodeConnectorNew;
- this.interfaceName = portName;
- }
-
- @Override
- public Object call() throws Exception {
- // If another renderer(for eg : OVS) needs to be supported, check can be performed here
- // to call the respective helpers.
- return addState(key, interfaceName, fcNodeConnectorNew);
- }
-
- @Override
- public String toString() {
- return "TunnelInterfaceStateAddWorker{fcNodeConnectorIdentifier=" + key + ", fcNodeConnectorNew="
- + fcNodeConnectorNew + ", interfaceName='" + interfaceName + '\'' + '}';
- }
- }
-
private class TunnelInterfaceStateUpdateWorker implements Callable {
private final InstanceIdentifier<FlowCapableNodeConnector> key;
private final FlowCapableNodeConnector fcNodeConnectorOld;
private static final Logger LOG = LoggerFactory.getLogger(TunnelListenerCreator.class);
- private final DpnTepStateListener dpnTepStateListener;
- private final DpnTepsInfoListener dpnTepsInfoListener;
private final TunnelTopologyStateListener tunnelTopologyStateListener;
private final TunnelInventoryStateListener tunnelInventoryStateListener;
private final TerminationPointStateListener terminationPointStateListener;
final TunnelStateCache tunnelStateCache,
final UnprocessedNodeConnectorCache unprocessedNodeConnectorCache,
final UnprocessedNodeConnectorEndPointCache
- unprocessedNodeConnectorEndPointCache) {
+ unprocessedNodeConnectorEndPointCache) {
if (interfaceManager.isItmDirectTunnelsEnabled()) {
- LOG.trace("ITM Direct Tunnels is enabled. Initializing the listeners");
- this.dpnTepStateListener = new DpnTepStateListener(dataBroker, coordinator, entityOwnershipUtils,
- dpnTepStateCache, dpntePsInfoCache, unprocessedNodeConnectorCache,
- unprocessedNodeConnectorEndPointCache, directTunnelUtils);
- this.dpnTepsInfoListener = new DpnTepsInfoListener(dataBroker, coordinator, entityOwnershipUtils,
- dpnTepStateCache, dpntePsInfoCache, unprocessedNodeConnectorCache,
- unprocessedNodeConnectorEndPointCache, interfaceManager, directTunnelUtils);
+ LOG.debug("ITM Direct Tunnels is enabled. Initializing the listeners");
this.tunnelTopologyStateListener = new TunnelTopologyStateListener(dataBroker, coordinator,
- entityOwnershipUtils, directTunnelUtils, dpnTepStateCache, dpntePsInfoCache, ovsBridgeEntryCache,
- unprocessedNodeConnectorCache, unprocessedNodeConnectorEndPointCache);
+ directTunnelUtils, dpnTepStateCache, ovsBridgeEntryCache);
this.tunnelInventoryStateListener = new TunnelInventoryStateListener(dataBroker, coordinator,
- entityOwnershipUtils, tunnelStateCache, dpnTepStateCache, dpntePsInfoCache,
- unprocessedNodeConnectorCache, unprocessedNodeConnectorEndPointCache, directTunnelUtils);
+ tunnelStateCache, dpnTepStateCache, dpntePsInfoCache, unprocessedNodeConnectorCache,
+ unprocessedNodeConnectorEndPointCache, directTunnelUtils);
this.terminationPointStateListener = new TerminationPointStateListener(dataBroker, entityOwnershipUtils,
- coordinator, bfdStateCache, dpnTepStateCache,tunnelStateCache);
+ coordinator, bfdStateCache, dpnTepStateCache,tunnelStateCache);
this.interfaceConfigListener = new InterfaceConfigListener(dataBroker, coordinator);
this.internalTunnelListener = new InternalTunnelListener(dataBroker, coordinator);
} else {
- LOG.trace("ITM Direct Tunnels is disabled. Listeners are not registered");
- this.dpnTepStateListener = null;
- this.dpnTepsInfoListener = null;
+ LOG.debug("ITM Direct Tunnels is disabled. Listeners are not registered");
this.tunnelTopologyStateListener = null;
this.tunnelInventoryStateListener = null;
this.terminationPointStateListener = null;
@Override
public void close() throws Exception {
- if (dpnTepStateListener != null) {
- this.dpnTepStateListener.close();
- }
if (tunnelTopologyStateListener != null) {
this.tunnelTopologyStateListener.close();
}
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
-import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.genius.itm.cache.OvsBridgeEntryCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
-import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
import org.opendaylight.genius.itm.globals.ITMConstants;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
-import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
+import org.opendaylight.serviceutils.tools.mdsal.listener.AbstractClusteredSyncDataTreeChangeListener;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.bridge.tunnel.info.OvsBridgeEntryBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class TunnelTopologyStateListener extends AbstractTunnelListenerBase<OvsdbBridgeAugmentation> {
+public class TunnelTopologyStateListener extends AbstractClusteredSyncDataTreeChangeListener<OvsdbBridgeAugmentation> {
private static final Logger LOG = LoggerFactory.getLogger(TunnelTopologyStateListener.class);
private final ManagedNewTransactionRunner txRunner;
private final DirectTunnelUtils directTunnelUtils;
private final OvsBridgeEntryCache ovsBridgeEntryCache;
+ protected final DpnTepStateCache dpnTepStateCache;
public TunnelTopologyStateListener(final DataBroker dataBroker,
final JobCoordinator coordinator,
- final EntityOwnershipUtils entityOwnershipUtils,
final DirectTunnelUtils directTunnelUtils,
final DpnTepStateCache dpnTepStateCache,
- final DPNTEPsInfoCache dpntePsInfoCache,
- final OvsBridgeEntryCache ovsBridgeEntryCache,
- final UnprocessedNodeConnectorCache unprocessedNodeConnectorCache,
- final UnprocessedNodeConnectorEndPointCache
- unprocessedNodeConnectorEndPointCache) {
+ final OvsBridgeEntryCache ovsBridgeEntryCache) {
super(dataBroker, LogicalDatastoreType.OPERATIONAL,
InstanceIdentifier.create(NetworkTopology.class).child(Topology.class).child(Node.class)
- .augmentation(OvsdbBridgeAugmentation.class), dpnTepStateCache, dpntePsInfoCache,
- unprocessedNodeConnectorCache, unprocessedNodeConnectorEndPointCache,
- entityOwnershipUtils, directTunnelUtils);
+ .augmentation(OvsdbBridgeAugmentation.class));
this.coordinator = coordinator;
+ this.dpnTepStateCache = dpnTepStateCache;
this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
this.directTunnelUtils = directTunnelUtils;
this.ovsBridgeEntryCache = ovsBridgeEntryCache;
@Override
public void remove(@Nonnull InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
@Nonnull OvsdbBridgeAugmentation bridgeOld) {
- if (entityOwner()) {
+ if (directTunnelUtils.isEntityOwner()) {
LOG.debug("Received Remove DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
identifier, bridgeOld);
TunnelRendererStateRemoveWorker rendererStateRemoveWorker =
public void update(@Nonnull InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
@Nonnull OvsdbBridgeAugmentation bridgeOld, @Nonnull OvsdbBridgeAugmentation bridgeNew) {
- if (!entityOwner()) {
+ if (!directTunnelUtils.isEntityOwner()) {
return;
}
LOG.debug("Received Update DataChange Notification for identifier: {}, + ovsdbBridgeAugmentation old: {},"
@Override
public void add(@Nonnull InstanceIdentifier<OvsdbBridgeAugmentation> identifier,
@Nonnull OvsdbBridgeAugmentation bridgeNew) {
- if (entityOwner()) {
+ if (directTunnelUtils.isEntityOwner()) {
LOG.debug("Received Add DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
identifier, bridgeNew);
TunnelRendererStateAddWorker rendererStateAddWorker =
import javax.annotation.Nonnull;
import javax.inject.Inject;
import javax.inject.Singleton;
-
import org.opendaylight.genius.infra.Datastore.Configuration;
import org.opendaylight.genius.infra.TypedReadWriteTransaction;
import org.opendaylight.genius.infra.TypedWriteTransaction;
import org.opendaylight.genius.mdsalutil.instructions.InstructionWriteMetadata;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
import org.opendaylight.genius.mdsalutil.matches.MatchInPort;
+import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.utils.concurrent.KeyedLocks;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
private final IdManagerService idManagerService;
private final IMdsalApiManager mdsalApiManager;
+ private final EntityOwnershipUtils entityOwnershipUtils;
@Inject
- public DirectTunnelUtils(final IdManagerService idManagerService, final IMdsalApiManager mdsalApiManager) {
+ public DirectTunnelUtils(final IdManagerService idManagerService, final IMdsalApiManager mdsalApiManager,
+ final EntityOwnershipUtils entityOwnershipUtils) {
this.idManagerService = idManagerService;
this.mdsalApiManager = mdsalApiManager;
+ this.entityOwnershipUtils = entityOwnershipUtils;
}
public KeyedLocks<String> getTunnelLocks() {
tpBuilder.addAugmentation(OvsdbTerminationPointAugmentation.class, tpAugmentationBuilder.build());
ITMBatchingUtils.update(tpIid, tpBuilder.build(), ITMBatchingUtils.EntityType.TOPOLOGY_CONFIG);
}
-}
+
+ public boolean isEntityOwner() {
+ return entityOwnershipUtils.isEntityOwner(ITMConstants.ITM_CONFIG_ENTITY, ITMConstants.ITM_CONFIG_ENTITY);
+ }
+}
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.itm.itmdirecttunnels.workers;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import org.opendaylight.genius.infra.Datastore;
+import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
+import org.opendaylight.genius.interfacemanager.globals.IfmConstants;
+import org.opendaylight.genius.itm.globals.ITMConstants;
+import org.opendaylight.genius.itm.impl.ITMBatchingUtils;
+import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
+import org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo;
+import org.opendaylight.genius.itm.utils.TunnelStateInfo;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.IfIndexesTunnelMap;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnelBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnelKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.state.tunnel.list.DstInfoBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.state.tunnel.list.SrcInfoBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.OperationFailedException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class TunnelStateAddWorker {
+
+ private static final Logger LOG = LoggerFactory.getLogger(TunnelStateAddWorker.class);
+
+ private final DirectTunnelUtils directTunnelUtils;
+ private final ManagedNewTransactionRunner txRunner;
+
+ public TunnelStateAddWorker(final DirectTunnelUtils directTunnelUtils, final ManagedNewTransactionRunner txRunner) {
+ this.directTunnelUtils = directTunnelUtils;
+ this.txRunner = txRunner;
+ }
+
+ public List<ListenableFuture<Void>> addState(TunnelStateInfo tunnelStateInfo)
+ throws ExecutionException, InterruptedException, OperationFailedException {
+
+ // When this method is invoked, all parameters necessary should be available
+ // Retrieve Port No from nodeConnectorId
+ NodeConnectorId nodeConnectorId = InstanceIdentifier.keyOf(tunnelStateInfo.getNodeConnectorInfo()
+ .getNodeConnectorId().firstIdentifierOf(NodeConnector.class)).getId();
+ String interfaceName = tunnelStateInfo.getNodeConnectorInfo().getNodeConnector().getName();
+ long portNo = DirectTunnelUtils.getPortNumberFromNodeConnectorId(nodeConnectorId);
+ if (portNo == ITMConstants.INVALID_PORT_NO) {
+ LOG.error("Cannot derive port number, not proceeding with Interface State addition for interface: {}",
+ interfaceName);
+ return Collections.emptyList();
+ }
+
+ LOG.info("adding interface state to Oper DS for interface: {}", interfaceName);
+
+ // Fetch the interface/Tunnel from config DS if exists
+ // If it doesnt exists then "park" the processing and comeback to it when the data is available and
+ // this will be triggered by the corres. listener. Caching and de-caching has to be synchronized.
+ StateTunnelList stateTnl = addStateEntry(interfaceName, portNo, tunnelStateInfo);
+
+ // This will be only tunnel If so not required
+ // If this interface is a tunnel interface, create the tunnel ingress flow,
+ // and start tunnel monitoring
+ if (stateTnl != null) {
+ return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION,
+ tx -> directTunnelUtils.addTunnelIngressFlow(tx,
+ DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId), portNo, interfaceName,
+ stateTnl.getIfIndex())));
+ }
+ return Collections.emptyList();
+ }
+
+ private StateTunnelList addStateEntry(String interfaceName, long portNo, TunnelStateInfo tunnelStateInfo)
+ throws ExecutionException, InterruptedException, OperationFailedException {
+ LOG.debug("Start addStateEntry adding interface state for {}", interfaceName);
+ final StateTunnelListBuilder stlBuilder = new StateTunnelListBuilder();
+ Class<? extends TunnelTypeBase> tunnelType;
+ DPNTEPsInfo srcDpnTepsInfo = tunnelStateInfo.getSrcDpnTepsInfo();
+
+ DpnTepInterfaceInfo dpnTepInfo = tunnelStateInfo.getDpnTepInterfaceInfo();
+ LOG.debug("Source Dpn TEP Interface Info {}", dpnTepInfo);
+ tunnelType = dpnTepInfo.getTunnelType();
+
+ final SrcInfoBuilder srcInfoBuilder =
+ new SrcInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getSrcEndPointInfo());
+ final DstInfoBuilder dstInfoBuilder =
+ new DstInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getDstEndPointInfo());
+ LOG.trace("Source Dpn TEP Info {}",srcDpnTepsInfo);
+ TunnelEndPoints srcEndPtInfo = srcDpnTepsInfo.getTunnelEndPoints().get(0);
+ srcInfoBuilder.setTepIp(srcEndPtInfo.getIpAddress());
+ // As ITM Direct Tunnels deals with only Internal Tunnels.
+ // Relook at this when it deals with external as well
+ srcInfoBuilder.setTepDeviceType(TepTypeInternal.class);
+
+ DPNTEPsInfo dstDpnTePsInfo = tunnelStateInfo.getDstDpnTepsInfo();
+ LOG.trace("Dest Dpn TEP Info {}", dstDpnTePsInfo);
+ TunnelEndPoints dstEndPtInfo = dstDpnTePsInfo.getTunnelEndPoints().get(0);
+ dstInfoBuilder.setTepIp(dstEndPtInfo.getIpAddress());
+ // As ITM Direct Tunnels deals with only Internal Tunnels.
+ // Relook at this when it deals with external as well
+ dstInfoBuilder.setTepDeviceType(TepTypeInternal.class);
+
+ Interface.OperStatus operStatus = Interface.OperStatus.Up;
+
+ // ITM Direct Tunnels NOT SETTING THE TEP TYPe coz its not available. CHECK IF REQUIRED
+ TunnelOperStatus tunnelOperStatus = DirectTunnelUtils.convertInterfaceToTunnelOperState(operStatus);
+ boolean tunnelState = operStatus.equals(Interface.OperStatus.Up);
+
+ StateTunnelListKey tlKey = new StateTunnelListKey(interfaceName);
+ stlBuilder.withKey(tlKey).setOperState(tunnelOperStatus).setTunnelState(tunnelState)
+ .setDstInfo(dstInfoBuilder.build()).setSrcInfo(srcInfoBuilder.build()).setTransportType(tunnelType)
+ .setPortNumber(String.valueOf(portNo));
+ int ifIndex = directTunnelUtils.allocateId(IfmConstants.IFM_IDPOOL_NAME, interfaceName);
+ createLportTagInterfaceMap(interfaceName, ifIndex);
+ stlBuilder.setIfIndex(ifIndex);
+ InstanceIdentifier<StateTunnelList> stListId = ItmUtils.buildStateTunnelListId(tlKey);
+ LOG.info("Batching the Creation of tunnel_state: {} for Id: {}", stlBuilder.build(), stListId);
+ ITMBatchingUtils.write(stListId, stlBuilder.build(), ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
+ return stlBuilder.build();
+ }
+
+ private void createLportTagInterfaceMap(String infName, Integer ifIndex) {
+ LOG.debug("creating lport tag to interface map for {}", infName);
+ InstanceIdentifier<IfIndexTunnel> id = InstanceIdentifier.builder(IfIndexesTunnelMap.class)
+ .child(IfIndexTunnel.class, new IfIndexTunnelKey(ifIndex)).build();
+ IfIndexTunnel ifIndexInterface = new IfIndexTunnelBuilder().setIfIndex(ifIndex)
+ .withKey(new IfIndexTunnelKey(ifIndex)).setInterfaceName(infName).build();
+ ITMBatchingUtils.write(id, ifIndexInterface, ITMBatchingUtils.EntityType.DEFAULT_OPERATIONAL);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2018 Ericsson India Global Services Pvt Ltd. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.itm.itmdirecttunnels.workers;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.List;
+import java.util.concurrent.Callable;
+import org.opendaylight.genius.itm.utils.TunnelStateInfo;
+
+public class TunnelStateAddWorkerForNodeConnector implements Callable<List<ListenableFuture<Void>>> {
+ private final TunnelStateAddWorker tunnelStateAddWorker;
+ private final TunnelStateInfo tunnelStateInfo;
+
+ public TunnelStateAddWorkerForNodeConnector(TunnelStateAddWorker tunnelStateAddWorker,
+ TunnelStateInfo tunnelStateInfo) {
+ this.tunnelStateAddWorker = tunnelStateAddWorker;
+ this.tunnelStateInfo = tunnelStateInfo;
+ }
+
+ @Override
+ public List<ListenableFuture<Void>> call() throws Exception {
+ // If another renderer(for eg : OVS) needs to be supported, check can be performed here
+ // to call the respective helpers.
+ return tunnelStateAddWorker.addState(tunnelStateInfo);
+ }
+
+ @Override
+ public String toString() {
+ return "TunnelStateAddWorkerForNodeConnector{tunnelStateInfo=" + tunnelStateInfo + '}';
+ }
+}
\ No newline at end of file
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
+import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
import org.opendaylight.genius.itm.confighelpers.HwVtep;
import org.opendaylight.genius.itm.confighelpers.ItmExternalTunnelAddWorker;
import org.opendaylight.genius.itm.globals.ITMConstants;
+import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
+import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
+import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
Optional<TunnelMonitorInterval> tunnelMonitorIntervalOptional ;
@Mock DataBroker dataBroker;
+ @Mock JobCoordinator jobCoordinator;
@Mock ReadOnlyTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
@Mock IdManagerService idManagerService;
@Mock ItmConfig itmConfig;
+ @Mock EntityOwnershipUtils entityOwnershipUtils;
private ItmExternalTunnelAddWorker externalTunnelAddWorker;
+ DirectTunnelUtils directTunnelUtils;
+ UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
@Before
public void setUp() {
.when(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, tunnelMonitorIntervalIdentifier);
externalTunnelAddWorker = new ItmExternalTunnelAddWorker(dataBroker, itmConfig,
- new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())));
+ new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
+ directTunnelUtils, jobCoordinator, unprocessedNodeConnectorEndPointCache));
}
import org.opendaylight.genius.itm.cache.OvsBridgeEntryCache;
import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
import org.opendaylight.genius.itm.cache.TunnelStateCache;
+import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
+import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
import org.opendaylight.genius.itm.confighelpers.ItmInternalTunnelDeleteWorker;
import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
@Mock IMdsalApiManager mdsalApiManager;
@Mock JobCoordinator jobCoordinator;
@Mock IInterfaceManager interfaceManager;
- DirectTunnelUtils directTunnelUtils;
@Mock ItmConfig itmConfig;
@Mock TunnelMonitoringConfig tunnelMonitoringConfig;
+ DirectTunnelUtils directTunnelUtils;
ItmInternalTunnelDeleteWorker itmInternalTunnelDeleteWorker;
+ UnprocessedNodeConnectorCache unprocessedNodeConnectorCache;
+ UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
+
Optional<TunnelMonitorParams> tunnelMonitorParamsOptional;
Optional<TunnelMonitorInterval> tunnelMonitorIntervalOptional ;
doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadWriteTx)
.read(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifier);
+ DPNTEPsInfoCache dpntePsInfoCache =
+ new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
+ directTunnelUtils, jobCoordinator, unprocessedNodeConnectorEndPointCache);
+
itmInternalTunnelDeleteWorker = new ItmInternalTunnelDeleteWorker(dataBroker, jobCoordinator,
- new TunnelMonitoringConfig(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
- interfaceManager,
- new DpnTepStateCache(dataBroker,new GuavaCacheProvider(new CacheManagersRegistryImpl()),
- new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()))),
- new OvsBridgeEntryCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
- new OvsBridgeRefEntryCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
- new TunnelStateCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
- directTunnelUtils);
+ new TunnelMonitoringConfig(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
+ interfaceManager, new DpnTepStateCache(dataBroker, jobCoordinator,
+ new GuavaCacheProvider(new CacheManagersRegistryImpl()), directTunnelUtils, dpntePsInfoCache,
+ unprocessedNodeConnectorCache, unprocessedNodeConnectorEndPointCache),
+ new OvsBridgeEntryCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
+ new OvsBridgeRefEntryCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
+ new TunnelStateCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl())),
+ directTunnelUtils);
}
@After
import org.opendaylight.genius.itm.cache.DpnTepStateCache;
import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
import org.opendaylight.genius.itm.cache.TunnelStateCache;
+import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
+import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
import org.opendaylight.genius.itm.globals.ITMConstants;
+import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
import org.opendaylight.genius.itm.rpc.ItmManagerRpcService;
import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
+import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
+import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
.child(Subnets.class, new SubnetsKey(ipPrefixTest)).child(DeviceVteps.class, deviceVtepKey).build();
@Mock DataBroker dataBroker;
+ @Mock JobCoordinator jobCoordinator;
@Mock ReadOnlyTransaction mockReadTx;
@Mock WriteTransaction mockWriteTx;
@Mock IMdsalApiManager mdsalApiManager;
@Mock ItmConfig itmConfig;
@Mock IInterfaceManager interfaceManager;
@Mock InterfaceManagerService interfaceManagerService;
+ @Mock EntityOwnershipUtils entityOwnershipUtils;
ItmManagerRpcService itmManagerRpcService ;
+ DirectTunnelUtils directTunnelUtils;
+ UnprocessedNodeConnectorCache unprocessedNodeConnectorCache;
+ UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
Optional<ExternalTunnel> externalTunnelOptional ;
Optional<InternalTunnel> internalTunnelOptional;
.CONFIGURATION,transportZonesIdentifier);
DPNTEPsInfoCache dpntePsInfoCache =
- new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()));
+ new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
+ directTunnelUtils, jobCoordinator, unprocessedNodeConnectorEndPointCache);
DpnTepStateCache dpnTepStateCache =
- new DpnTepStateCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
- dpntePsInfoCache);
+ new DpnTepStateCache(dataBroker, jobCoordinator, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
+ directTunnelUtils, dpntePsInfoCache, unprocessedNodeConnectorCache, unprocessedNodeConnectorEndPointCache);
TunnelStateCache tunnelStateCache =
new TunnelStateCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()));
OvsBridgeRefEntryCache ovsBridgeRefEntryCache =
itmManagerRpcService = new ItmManagerRpcService(dataBroker, mdsalApiManager, itmConfig,
dpntePsInfoCache, interfaceManager, dpnTepStateCache, tunnelStateCache, interfaceManagerService,
- ovsBridgeRefEntryCache, null);
+ ovsBridgeRefEntryCache, directTunnelUtils);
}
@After
Code Review / genius.git / commitdiff