From d7641b979d1ed995abfe1cc4b5d30853f9ac3763 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Sat, 12 Oct 2019 15:09:53 +0200 Subject: [PATCH] Make TunnelEndPointInfo work on Uint64 Rather than forcing Uint64->String conversion and subsequent String->Uint64 conversions, make TunnelEndPointInfo store Uint64s and lazily derive (and cache) String representation. Change-Id: I233172af5b75da589609401d037f1b65bf44e8d1 Signed-off-by: Robert Varga --- .../genius/itm/utils/TunnelEndPointInfo.java | 15 ++++++- .../genius/itm/cache/DPNTEPsInfoCache.java | 41 ++++++++++--------- .../genius/itm/cache/DpnTepStateCache.java | 32 +++++++-------- .../TunnelInventoryStateListener.java | 14 ++++--- .../workers/TunnelStateAddWorker.java | 4 +- .../genius/itm/rpc/ItmManagerRpcService.java | 6 +-- 6 files changed, 63 insertions(+), 49 deletions(-) diff --git a/itm/itm-api/src/main/java/org/opendaylight/genius/itm/utils/TunnelEndPointInfo.java b/itm/itm-api/src/main/java/org/opendaylight/genius/itm/utils/TunnelEndPointInfo.java index b28b19c30..50bef6f17 100644 --- a/itm/itm-api/src/main/java/org/opendaylight/genius/itm/utils/TunnelEndPointInfo.java +++ b/itm/itm-api/src/main/java/org/opendaylight/genius/itm/utils/TunnelEndPointInfo.java @@ -9,12 +9,23 @@ package org.opendaylight.genius.itm.utils; import org.immutables.value.Value; import org.opendaylight.genius.infra.OpenDaylightImmutableStyle; +import org.opendaylight.yangtools.yang.common.Uint64; @Value.Immutable @OpenDaylightImmutableStyle public interface TunnelEndPointInfo { - String getSrcEndPointInfo(); + Uint64 getSrcEndPointInfo(); - String getDstEndPointInfo(); + Uint64 getDstEndPointInfo(); + + @Value.Lazy + default String getSrcEndPointName() { + return getSrcEndPointInfo().toString(); + } + + @Value.Lazy + default String getDstEndPointName() { + return getDstEndPointInfo().toString(); + } } diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java index 9d33cd42b..f0b3cd2d1 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DPNTEPsInfoCache.java @@ -69,12 +69,13 @@ public class DPNTEPsInfoCache extends InstanceIdDataObjectCache { @Override protected void added(InstanceIdentifier path, DPNTEPsInfo dpnTepsInfo) { - LOG.info("DPNTepsInfo Add Received for {}", dpnTepsInfo.getDPNID()); - String dpnId = dpnTepsInfo.getDPNID().toString(); + final Uint64 dpnId = dpnTepsInfo.getDPNID(); + final String dpnIdStr = dpnId.toString(); + LOG.info("DPNTepsInfo Add Received for {}", dpnIdStr); Collection tunnelStateInfoList; - try (Acquired lock = directTunnelUtils.lockTunnel(dpnId)) { - tunnelStateInfoList = unprocessedNodeConnectorEndPointCache.remove(dpnId); + try (Acquired lock = directTunnelUtils.lockTunnel(dpnIdStr)) { + tunnelStateInfoList = unprocessedNodeConnectorEndPointCache.remove(dpnIdStr); } if (tunnelStateInfoList != null) { @@ -89,9 +90,10 @@ public class DPNTEPsInfoCache extends InstanceIdDataObjectCache { dstDpnTepsInfo = tsInfo.getDstDpnTepsInfo(); if (dstDpnTepsInfo == null) { // Check if the destination End Point has come - try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPointInfo.getDstEndPointInfo())) { + final String dstEndpoint = tunnelEndPointInfo.getDstEndPointName(); + try (Acquired lock = directTunnelUtils.lockTunnel(dstEndpoint)) { Optional dstInfoOpt = getDPNTepFromDPNId( - Uint64.valueOf(tunnelEndPointInfo.getDstEndPointInfo())); + tunnelEndPointInfo.getDstEndPointInfo()); if (dstInfoOpt.isPresent()) { dstDpnTepsInfo = dstInfoOpt.get(); } else { @@ -99,11 +101,11 @@ public class DPNTEPsInfoCache extends InstanceIdDataObjectCache { .setNodeConnectorInfo(tsInfo.getNodeConnectorInfo()) .setDpnTepInterfaceInfo(tsInfo.getDpnTepInterfaceInfo()) .setTunnelEndPointInfo(tsInfo.getTunnelEndPointInfo()) - .setSrcDpnTepsInfo(srcDpnTepsInfo).build(); + .setSrcDpnTepsInfo(srcDpnTepsInfo) + .build(); LOG.trace("Destination DPNTepsInfo is null for tunnel {}. Hence Parking with key {}", - interfaceName, tunnelEndPointInfo.getDstEndPointInfo()); - unprocessedNodeConnectorEndPointCache.add(tunnelEndPointInfo - .getDstEndPointInfo(), tunnelStateInfoNew); + interfaceName, dstEndpoint); + unprocessedNodeConnectorEndPointCache.add(dstEndpoint, tunnelStateInfoNew); } } } @@ -112,22 +114,23 @@ public class DPNTEPsInfoCache extends InstanceIdDataObjectCache { srcDpnTepsInfo = tsInfo.getSrcDpnTepsInfo(); // Check if the destination End Point has come if (srcDpnTepsInfo == null) { - try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPointInfo.getSrcEndPointInfo())) { + final String srcEndpoint = tunnelEndPointInfo.getSrcEndPointName(); + try (Acquired lock = directTunnelUtils.lockTunnel(srcEndpoint)) { Optional srcInfoOpt = getDPNTepFromDPNId( - Uint64.valueOf(tunnelEndPointInfo.getSrcEndPointInfo())); + 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(); + 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); + unprocessedNodeConnectorEndPointCache.add(srcEndpoint, tunnelStateInfoNew); } } } diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java index 028ff6edb..b91d17a79 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/cache/DpnTepStateCache.java @@ -100,8 +100,8 @@ public class DpnTepStateCache extends DataObjectCache { .setRemoteDPN(remoteDpns.getDestinationDpnId()).build(); dpnTepInterfaceMap.put(dpn, value); - addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(), dpnsTeps.getSourceDpnId().toString(), - remoteDpns.getDestinationDpnId().toString()); + addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(), dpnsTeps.getSourceDpnId(), + remoteDpns.getDestinationDpnId()); //Process the unprocessed NodeConnector for the Tunnel, if present in the UnprocessedNodeConnectorCache @@ -119,8 +119,8 @@ public class DpnTepStateCache extends DataObjectCache { if (tunnelStateInfo != null) { LOG.debug("Processing the Unprocessed NodeConnector for Tunnel {}", remoteDpns.getTunnelName()); - TunnelEndPointInfo tunnelEndPtInfo = getTunnelEndPointInfo(dpnsTeps.getSourceDpnId().toString(), - remoteDpns.getDestinationDpnId().toString()); + TunnelEndPointInfo tunnelEndPtInfo = getTunnelEndPointInfo(dpnsTeps.getSourceDpnId(), + remoteDpns.getDestinationDpnId()); TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder() .setNodeConnectorInfo(tunnelStateInfo.getNodeConnectorInfo()).setDpnTepInterfaceInfo(value) .setTunnelEndPointInfo(tunnelEndPtInfo); @@ -131,7 +131,7 @@ public class DpnTepStateCache extends DataObjectCache { tunnelStateInfoNew = builder.build(); if (tunnelStateInfoNew.getSrcDpnTepsInfo() == null) { - String srcDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getSrcEndPointInfo(); + 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); @@ -140,7 +140,7 @@ public class DpnTepStateCache extends DataObjectCache { } if (tunnelStateInfoNew.getDstDpnTepsInfo() == null) { - String dstDpnId = tunnelStateInfoNew.getTunnelEndPointInfo().getDstEndPointInfo(); + 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); @@ -171,10 +171,6 @@ public class DpnTepStateCache extends DataObjectCache { } } - private DpnTepInterfaceInfo getDpnTepInterface(String srcDpnId, String dstDpnId) { - return getDpnTepInterface(Uint64.valueOf(srcDpnId), Uint64.valueOf(dstDpnId)); - } - public DpnTepInterfaceInfo getDpnTepInterface(Uint64 srcDpnId, Uint64 dstDpnId) { DpnTepInterfaceInfo dpnTepInterfaceInfo = dpnTepInterfaceMap.get(getDpnId(srcDpnId, dstDpnId)); if (dpnTepInterfaceInfo == null) { @@ -191,7 +187,7 @@ public class DpnTepStateCache extends DataObjectCache { .setRemoteDPN(remoteDpns.getDestinationDpnId()).build(); dpnTepInterfaceMap.putIfAbsent(getDpnId(srcDpnId, remoteDpns.getDestinationDpnId()), value); addTunnelEndPointInfoToCache(remoteDpns.getTunnelName(), - teps.getSourceDpnId().toString(), remoteDpns.getDestinationDpnId().toString()); + teps.getSourceDpnId(), remoteDpns.getDestinationDpnId()); } ); } @@ -272,8 +268,8 @@ public class DpnTepStateCache extends DataObjectCache { public Interface getInterfaceFromCache(String tunnelName) { TunnelEndPointInfo endPointInfo = getTunnelEndPointInfoFromCache(tunnelName); - Uint64 srcDpnId = Uint64.valueOf(endPointInfo.getSrcEndPointInfo()); - Uint64 dstDpnId = Uint64.valueOf(endPointInfo.getDstEndPointInfo()); + Uint64 srcDpnId = endPointInfo.getSrcEndPointInfo(); + Uint64 dstDpnId = endPointInfo.getDstEndPointInfo(); Interface iface = null ; int monitoringInt = 1000; DpnTepInterfaceInfo dpnTepInfo = getDpnTepInterface(srcDpnId, dstDpnId); @@ -294,13 +290,15 @@ public class DpnTepStateCache extends DataObjectCache { } //Start: TunnelEndPoint Cache accessors - private void addTunnelEndPointInfoToCache(String tunnelName, String srcEndPtInfo, String dstEndPtInfo) { + private void addTunnelEndPointInfoToCache(String tunnelName, Uint64 srcEndPtInfo, Uint64 dstEndPtInfo) { tunnelEndpointMap.put(tunnelName, getTunnelEndPointInfo(srcEndPtInfo,dstEndPtInfo)); } - private TunnelEndPointInfo getTunnelEndPointInfo(String srcEndPtInfo, String dstEndPtInfo) { - return - new TunnelEndPointInfoBuilder().setSrcEndPointInfo(srcEndPtInfo).setDstEndPointInfo(dstEndPtInfo).build(); + private static TunnelEndPointInfo getTunnelEndPointInfo(Uint64 srcEndPtInfo, Uint64 dstEndPtInfo) { + return new TunnelEndPointInfoBuilder() + .setSrcEndPointInfo(srcEndPtInfo) + .setDstEndPointInfo(dstEndPtInfo) + .build(); } public TunnelEndPointInfo getTunnelEndPointInfoFromCache(String tunnelName) { diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java index d6c65904e..550e76f87 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelInventoryStateListener.java @@ -296,25 +296,27 @@ public class TunnelInventoryStateListener extends if (DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && dpnTepStateCache.isInternal(portName)) { tunnelEndPtInfo = dpnTepStateCache.getTunnelEndPointInfoFromCache(portName); TunnelStateInfoBuilder builder = new TunnelStateInfoBuilder().setNodeConnectorInfo(nodeConnectorInfo); - dpntePsInfoCache.getDPNTepFromDPNId(Uint64.valueOf(tunnelEndPtInfo.getSrcEndPointInfo())) + dpntePsInfoCache.getDPNTepFromDPNId(tunnelEndPtInfo.getSrcEndPointInfo()) .ifPresent(builder::setSrcDpnTepsInfo); - dpntePsInfoCache.getDPNTepFromDPNId(Uint64.valueOf(tunnelEndPtInfo.getDstEndPointInfo())) + dpntePsInfoCache.getDPNTepFromDPNId(tunnelEndPtInfo.getDstEndPointInfo()) .ifPresent(builder::setDstDpnTepsInfo); tunnelStateInfo = builder.setTunnelEndPointInfo(tunnelEndPtInfo) .setDpnTepInterfaceInfo(dpnTepStateCache.getTunnelFromCache(portName)).build(); if (tunnelStateInfo.getSrcDpnTepsInfo() == null) { - try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPtInfo.getSrcEndPointInfo())) { + 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(tunnelEndPtInfo.getSrcEndPointInfo(), tunnelStateInfo); + unprocessedNodeConnectorEndPointCache.add(srcEndpoint, tunnelStateInfo); } } if (tunnelStateInfo.getDstDpnTepsInfo() == null) { - try (Acquired lock = directTunnelUtils.lockTunnel(tunnelEndPtInfo.getDstEndPointInfo())) { + 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(tunnelEndPtInfo.getDstEndPointInfo(), tunnelStateInfo); + unprocessedNodeConnectorEndPointCache.add(dstEndpoint, tunnelStateInfo); } } } diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java index 42210e065..19cf8a521 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/workers/TunnelStateAddWorker.java @@ -118,9 +118,9 @@ public final class TunnelStateAddWorker { tunnelType = dpnTepInfo.getTunnelType(); final SrcInfoBuilder srcInfoBuilder = - new SrcInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getSrcEndPointInfo()); + new SrcInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getSrcEndPointName()); final DstInfoBuilder dstInfoBuilder = - new DstInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getDstEndPointInfo()); + new DstInfoBuilder().setTepDeviceId(tunnelStateInfo.getTunnelEndPointInfo().getDstEndPointName()); LOG.trace("Source Dpn TEP Info {}",srcDpnTepsInfo); TunnelEndPoints srcEndPtInfo = srcDpnTepsInfo.getTunnelEndPoints().get(0); srcInfoBuilder.setTepIp(srcEndPtInfo.getIpAddress()); diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java index d63c8a565..90b916fe4 100644 --- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java +++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/rpc/ItmManagerRpcService.java @@ -1289,9 +1289,8 @@ public class ItmManagerRpcService implements ItmRpcService { .builder(DpnEndpoints.class) .child(DPNTEPsInfo.class, new DPNTEPsInfoKey( // FIXME: the cache should be caching this value, not just as a String - Uint64.valueOf(dpnTepStateCache.getTunnelEndPointInfoFromCache( - interfaceInfo.getTunnelName()).getDstEndPointInfo()))) - .build()); + dpnTepStateCache.getTunnelEndPointInfoFromCache( + interfaceInfo.getTunnelName()).getDstEndPointInfo())).build()); Integer dstId; if (dpntePsInfoOptional.isPresent()) { dstId = dpntePsInfoOptional.get().getDstId(); @@ -1311,6 +1310,7 @@ public class ItmManagerRpcService implements ItmRpcService { return Futures.immediateFuture(new GetEgressActionsForTunnelOutputBuilder() .setAction(result.stream().map(ActionInfo::buildAction).collect(Collectors.toList())).build()); + } } -- 2.36.6