Search in sources :

Example 1 with TunnelStateInfo

use of org.opendaylight.genius.itm.utils.TunnelStateInfo in project genius by opendaylight.

the class DPNTEPsInfoCache method added.

@Override
protected void added(InstanceIdentifier<DPNTEPsInfo> path, DPNTEPsInfo dpnTepsInfo) {
    final Uint64 dpnId = dpnTepsInfo.getDPNID();
    final String dpnIdStr = dpnId.toString();
    LOG.info("DPNTepsInfo Add Received for {}", dpnIdStr);
    Collection<TunnelStateInfo> tunnelStateInfoList;
    try (Acquired lock = directTunnelUtils.lockTunnel(dpnIdStr)) {
        tunnelStateInfoList = unprocessedNodeConnectorEndPointCache.remove(dpnIdStr);
    }
    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
                    final String dstEndpoint = tunnelEndPointInfo.getDstEndPointName();
                    try (Acquired lock = directTunnelUtils.lockTunnel(dstEndpoint)) {
                        Optional<DPNTEPsInfo> dstInfoOpt = getDPNTepFromDPNId(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, dstEndpoint);
                            unprocessedNodeConnectorEndPointCache.add(dstEndpoint, tunnelStateInfoNew);
                        }
                    }
                }
            } else if (dpnId.equals(tunnelEndPointInfo.getDstEndPointInfo())) {
                dstDpnTepsInfo = dpnTepsInfo;
                srcDpnTepsInfo = tsInfo.getSrcDpnTepsInfo();
                // Check if the destination End Point has come
                if (srcDpnTepsInfo == null) {
                    final String srcEndpoint = tunnelEndPointInfo.getSrcEndPointName();
                    try (Acquired lock = directTunnelUtils.lockTunnel(srcEndpoint)) {
                        Optional<DPNTEPsInfo> srcInfoOpt = getDPNTepFromDPNId(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(srcEndpoint, tunnelStateInfoNew);
                        }
                    }
                }
            }
            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);
                EVENT_LOGGER.debug("ITM-DpnTepsInfoCache,ADD {}", interfaceName);
                coordinator.enqueueJob(interfaceName, new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner), tunnelStateInfoNew), ITMConstants.JOB_MAX_RETRIES);
            }
        }
    }
}
Also used : TunnelStateAddWorkerForNodeConnector(org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorkerForNodeConnector) Optional(java.util.Optional) Acquired(org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired) TunnelStateAddWorker(org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorker) TunnelStateInfo(org.opendaylight.genius.itm.utils.TunnelStateInfo) TunnelEndPointInfo(org.opendaylight.genius.itm.utils.TunnelEndPointInfo) TunnelStateInfoBuilder(org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder) DPNTEPsInfo(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo) Uint64(org.opendaylight.yangtools.yang.common.Uint64)

Example 2 with TunnelStateInfo

use of org.opendaylight.genius.itm.utils.TunnelStateInfo in project genius by opendaylight.

the class DpnTepStateCache method added.

@Override
protected void added(InstanceIdentifier<DpnsTeps> path, DpnsTeps dpnsTeps) {
    String srcOfTunnel = dpnsTeps.getOfTunnel();
    for (RemoteDpns remoteDpns : dpnsTeps.nonnullRemoteDpns().values()) {
        DpnTepInterfaceInfo value = new DpnTepInterfaceInfoBuilder().setTunnelName(remoteDpns.getTunnelName()).setIsMonitoringEnabled(remoteDpns.isMonitoringEnabled()).setIsInternal(remoteDpns.isInternal()).setTunnelType(dpnsTeps.getTunnelType()).setRemoteDPN(remoteDpns.getDestinationDpnId()).build();
        final CacheKey key = new CacheKey(dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
        dpnTepInterfaceMap.put(key, value);
        addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(), dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
        // Process the unprocessed NodeConnector for the Tunnel, if present in the UnprocessedNodeConnectorCache
        final String dpn = key.toString();
        TunnelStateInfo tunnelStateInfoNew = null;
        TunnelStateInfo tunnelStateInfo;
        try (Acquired lock = directTunnelUtils.lockTunnel(remoteDpns.getTunnelName())) {
            if (srcOfTunnel != null) {
                tunnelStateInfo = unprocessedNCCache.remove(dpn);
                if (tunnelStateInfo == null) {
                    tunnelStateInfo = unprocessedNCCache.remove(remoteDpns.getTunnelName());
                }
            } else {
                tunnelStateInfo = unprocessedNCCache.remove(remoteDpns.getTunnelName());
            }
        }
        if (tunnelStateInfo != null) {
            LOG.debug("Processing the Unprocessed NodeConnector for Tunnel {}", remoteDpns.getTunnelName());
            TunnelEndPointInfo tunnelEndPtInfo = getTunnelEndPointInfo(dpnsTeps.getSourceDpnId(), remoteDpns.getDestinationDpnId());
            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().getSrcEndPointName();
                try (Acquired lock = directTunnelUtils.lockTunnel(srcDpnId)) {
                    LOG.debug("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}", remoteDpns.getTunnelName(), srcDpnId);
                    unprocessedNodeConnectorEndPointCache.add(srcDpnId, tunnelStateInfoNew);
                }
            }
            if (tunnelStateInfoNew.getDstDpnTepsInfo() == null) {
                String dstDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getDstEndPointName();
                try (Acquired lock = directTunnelUtils.lockTunnel(dstDpnId)) {
                    LOG.debug("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}", remoteDpns.getTunnelName(), dstDpnId);
                    unprocessedNodeConnectorEndPointCache.add(dstDpnId, tunnelStateInfoNew);
                }
            }
        }
        if (tunnelStateInfoNew != null && tunnelStateInfoNew.getSrcDpnTepsInfo() != null && tunnelStateInfoNew.getDstDpnTepsInfo() != null && directTunnelUtils.isEntityOwner()) {
            TunnelStateAddWorkerForNodeConnector ifStateAddWorker = new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner), tunnelStateInfoNew);
            EVENT_LOGGER.debug("ITM-DpnTepStateCache,ADD {}", remoteDpns.getTunnelName());
            coordinator.enqueueJob(remoteDpns.getTunnelName(), ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
        }
    }
}
Also used : TunnelStateAddWorkerForNodeConnector(org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorkerForNodeConnector) Acquired(org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired) TunnelStateAddWorker(org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorker) DpnTepInterfaceInfoBuilder(org.opendaylight.genius.itm.utils.DpnTepInterfaceInfoBuilder) TunnelStateInfo(org.opendaylight.genius.itm.utils.TunnelStateInfo) TunnelEndPointInfo(org.opendaylight.genius.itm.utils.TunnelEndPointInfo) TunnelStateInfoBuilder(org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder) RemoteDpns(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.teps.state.dpns.teps.RemoteDpns) DpnTepInterfaceInfo(org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo)

Example 3 with TunnelStateInfo

use of org.opendaylight.genius.itm.utils.TunnelStateInfo in project genius by opendaylight.

the class TunnelInventoryStateListener method addTunnelState.

private void addTunnelState(NodeConnectorInfo nodeConnectorInfo, String portName) {
    TunnelStateInfo tunnelStateInfo = null;
    TunnelEndPointInfo tunnelEndPtInfo = null;
    try (Acquired lock = directTunnelUtils.lockTunnel(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);
            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;
        }
    }
    // to UP as previously the compute would have disconnected and so the state will be UNKNOWN.
    try {
        long portNo = tunnelStateCache.getNodeConnectorIdFromInterface(portName);
        if (portNo != ITMConstants.INVALID_PORT_NO) {
            coordinator.enqueueJob(portName, new TunnelInterfaceNodeReconnectWorker(portName), ITMConstants.JOB_MAX_RETRIES);
            return;
        }
    } catch (ReadFailedException e) {
        LOG.error("Exception occurred in reconnect for portName {}, reason: {}.", portName, e.getMessage());
    }
    if (DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && dpnTepStateCache.isInternal(portName)) {
        tunnelEndPtInfo = dpnTepStateCache.getTunnelEndPointInfoFromCache(portName);
        TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder().setNodeConnectorInfo(nodeConnectorInfo);
        dpntePsInfoCache.getDPNTepFromDPNId(tunnelEndPtInfo.getSrcEndPointInfo()).ifPresent(builder::setSrcDpnTepsInfo);
        dpntePsInfoCache.getDPNTepFromDPNId(tunnelEndPtInfo.getDstEndPointInfo()).ifPresent(builder::setDstDpnTepsInfo);
        tunnelStateInfo = builder.setTunnelEndPointInfo(tunnelEndPtInfo).setDpnTepInterfaceInfo(dpnTepStateCache.getTunnelFromCache(portName)).build();
        if (tunnelStateInfo.getSrcDpnTepsInfo() == null) {
            final String srcEndpoint = tunnelEndPtInfo.getSrcEndPointName();
            try (Acquired lock = directTunnelUtils.lockTunnel(srcEndpoint)) {
                LOG.debug("Source DPNTepsInfo is null for tunnel {}. Hence Parking with key {}", portName, tunnelEndPtInfo.getSrcEndPointInfo());
                unprocessedNodeConnectorEndPointCache.add(srcEndpoint, tunnelStateInfo);
            }
        }
        if (tunnelStateInfo.getDstDpnTepsInfo() == null) {
            final String dstEndpoint = tunnelEndPtInfo.getDstEndPointName();
            try (Acquired lock = directTunnelUtils.lockTunnel(dstEndpoint)) {
                LOG.debug("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}", portName, tunnelEndPtInfo.getDstEndPointInfo());
                unprocessedNodeConnectorEndPointCache.add(dstEndpoint, tunnelStateInfo);
            }
        }
    }
    if (tunnelEndPtInfo != null && tunnelStateInfo.getSrcDpnTepsInfo() != null && tunnelStateInfo.getDstDpnTepsInfo() != null) {
        EVENT_LOGGER.debug("ITM-TunnelInventoryState Entity Owner,ADD {}", portName);
        coordinator.enqueueJob(portName, new TunnelStateAddWorkerForNodeConnector(new TunnelStateAddWorker(directTunnelUtils, txRunner), tunnelStateInfo), ITMConstants.JOB_MAX_RETRIES);
    }
}
Also used : TunnelStateAddWorkerForNodeConnector(org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorkerForNodeConnector) ReadFailedException(org.opendaylight.mdsal.common.api.ReadFailedException) Acquired(org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired) TunnelStateAddWorker(org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorker) TunnelStateInfo(org.opendaylight.genius.itm.utils.TunnelStateInfo) TunnelEndPointInfo(org.opendaylight.genius.itm.utils.TunnelEndPointInfo) TunnelStateInfoBuilder(org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder)

Example 4 with TunnelStateInfo

use of org.opendaylight.genius.itm.utils.TunnelStateInfo in project genius by opendaylight.

the class TunnelStateAddWorker method addState.

public List<? extends ListenableFuture<?>> 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 tunnelName = tunnelStateInfo.getNodeConnectorInfo().getNodeConnector().getName();
    if (tunnelName != null && tunnelName.startsWith("of")) {
        tunnelName = tunnelStateInfo.getDpnTepInterfaceInfo().getTunnelName();
    }
    String interfaceName = tunnelName;
    long portNo = DirectTunnelUtils.getPortNumberFromNodeConnectorId(nodeConnectorId);
    EVENT_LOGGER.debug("ITM-TunnelState, ADD to oper DS {}", interfaceName);
    if (portNo == ITMConstants.INVALID_PORT_NO) {
        LOG.error("Cannot derive port number, not proceeding with Interface State addition for interface: {}", interfaceName);
        EVENT_LOGGER.debug("ITM-TunnelState,ADD Table 0 flow for {} completed", 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);
    // and start tunnel monitoring
    if (stateTnl != null) {
        return Collections.singletonList(txRunner.callWithNewWriteOnlyTransactionAndSubmit(Datastore.CONFIGURATION, tx -> {
            Uint64 dpId = DirectTunnelUtils.getDpnFromNodeConnectorId(nodeConnectorId);
            directTunnelUtils.addTunnelIngressFlow(tx, dpId, portNo, interfaceName, stateTnl.getIfIndex().toJava(), tunnelStateInfo.getDstDpnTepsInfo().getTunnelEndPoints().get(0).getIpAddress().getIpv4Address());
            directTunnelUtils.addTunnelEgressFlow(tx, dpId, String.valueOf(portNo), tunnelStateInfo.getDstDpnTepsInfo().getDstId(), interfaceName, tunnelStateInfo.getDstDpnTepsInfo().getTunnelEndPoints().get(0).getIpAddress());
        }));
    }
    return Collections.emptyList();
}
Also used : Uint64(org.opendaylight.yangtools.yang.common.Uint64) ListenableFuture(com.google.common.util.concurrent.ListenableFuture) ITMBatchingUtils(org.opendaylight.genius.itm.impl.ITMBatchingUtils) SrcInfoBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.state.tunnel.list.SrcInfoBuilder) IfIndexTunnelBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnelBuilder) NodeConnector(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector) LoggerFactory(org.slf4j.LoggerFactory) ManagedNewTransactionRunner(org.opendaylight.mdsal.binding.util.ManagedNewTransactionRunner) TepTypeInternal(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TepTypeInternal) IfIndexTunnelKey(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnelKey) StateTunnelList(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList) DstInfoBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.state.tunnel.list.DstInfoBuilder) DpnTepInterfaceInfo(org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo) NodeConnectorId(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId) DPNTEPsInfo(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo) Datastore(org.opendaylight.mdsal.binding.util.Datastore) IfIndexesTunnelMap(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210.IfIndexesTunnelMap) DirectTunnelUtils(org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils) TunnelStateInfo(org.opendaylight.genius.itm.utils.TunnelStateInfo) StateTunnelListKey(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListKey) Logger(org.slf4j.Logger) IfIndexTunnel(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.meta.rev171210._if.indexes.tunnel.map.IfIndexTunnel) TunnelEndPoints(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints) StateTunnelListBuilder(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListBuilder) Interface(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface) OperationFailedException(org.opendaylight.yangtools.yang.common.OperationFailedException) IfmConstants(org.opendaylight.genius.interfacemanager.globals.IfmConstants) ExecutionException(java.util.concurrent.ExecutionException) List(java.util.List) InstanceIdentifier(org.opendaylight.yangtools.yang.binding.InstanceIdentifier) TunnelTypeBase(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase) TunnelOperStatus(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus) ITMConstants(org.opendaylight.genius.itm.globals.ITMConstants) Collections(java.util.Collections) ItmUtils(org.opendaylight.genius.itm.impl.ItmUtils) NodeConnectorId(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId) StateTunnelList(org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList) Uint64(org.opendaylight.yangtools.yang.common.Uint64)

Aggregations

TunnelStateInfo (org.opendaylight.genius.itm.utils.TunnelStateInfo)4 TunnelStateAddWorker (org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorker)3 TunnelStateAddWorkerForNodeConnector (org.opendaylight.genius.itm.itmdirecttunnels.workers.TunnelStateAddWorkerForNodeConnector)3 TunnelEndPointInfo (org.opendaylight.genius.itm.utils.TunnelEndPointInfo)3 TunnelStateInfoBuilder (org.opendaylight.genius.itm.utils.TunnelStateInfoBuilder)3 Acquired (org.opendaylight.infrautils.utils.concurrent.NamedSimpleReentrantLock.Acquired)3 DpnTepInterfaceInfo (org.opendaylight.genius.itm.utils.DpnTepInterfaceInfo)2 DPNTEPsInfo (org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo)2 Uint64 (org.opendaylight.yangtools.yang.common.Uint64)2 ListenableFuture (com.google.common.util.concurrent.ListenableFuture)1 Collections (java.util.Collections)1 List (java.util.List)1 Optional (java.util.Optional)1 ExecutionException (java.util.concurrent.ExecutionException)1 IfmConstants (org.opendaylight.genius.interfacemanager.globals.IfmConstants)1 ITMConstants (org.opendaylight.genius.itm.globals.ITMConstants)1 ITMBatchingUtils (org.opendaylight.genius.itm.impl.ITMBatchingUtils)1 ItmUtils (org.opendaylight.genius.itm.impl.ItmUtils)1 DirectTunnelUtils (org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils)1 DpnTepInterfaceInfoBuilder (org.opendaylight.genius.itm.utils.DpnTepInterfaceInfoBuilder)1