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 <robert.varga@pantheon.tech>

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 b28b19c30c64b45034f09bb49c5f52fc99f6fb5a..50bef6f172ea23705177a8785eabc31d04551b2f 100644 (file)
--- 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 9d33cd42bb97385213ddc6f4879f8322348594c0..f0b3cd2d18138773fb6289c218c48e3c948f39f7 100644 (file)
--- 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<DPNTEPsInfo> {
 
     @Override
     protected void added(InstanceIdentifier<DPNTEPsInfo> 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<TunnelStateInfo> 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<DPNTEPsInfo> {
                     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<DPNTEPsInfo> dstInfoOpt = getDPNTepFromDPNId(
-                                    Uint64.valueOf(tunnelEndPointInfo.getDstEndPointInfo()));
+                                    tunnelEndPointInfo.getDstEndPointInfo());
                             if (dstInfoOpt.isPresent()) {
                                 dstDpnTepsInfo = dstInfoOpt.get();
                             } else {
@@ -99,11 +101,11 @@ public class DPNTEPsInfoCache extends InstanceIdDataObjectCache<DPNTEPsInfo> {
                                     .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<DPNTEPsInfo> {
                     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<DPNTEPsInfo> 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 028ff6edb683c976a8ed9ac8ddc7d3e8adc9f273..b91d17a7908e72ffb22b9f661063dc188e5f911f 100644 (file)
--- 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<Uint64, DpnsTeps> {
                 .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<Uint64, DpnsTeps> {
             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<Uint64, DpnsTeps> {
 
                 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<Uint64, DpnsTeps> {
                 }
 
                 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<Uint64, DpnsTeps> {
         }
     }
 
-    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<Uint64, DpnsTeps> {
                                 .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<Uint64, DpnsTeps> {
 
     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<Uint64, DpnsTeps> {
     }
 
     //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 d6c65904e490c1e170122d5004873e00ef449d44..550e76f8781ce790453138e29b82900c66fbb7fc 100644 (file)
--- 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 42210e065499166ccd32b8fbe912ba84ff703ab9..19cf8a521ded42d4a1ed9186f8177bbfc8fbe727 100644 (file)
--- 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 d63c8a565408abce2f86dc7378acee9bcb86d85c..90b916fe41f79f0a04709ac8d6a03eb09973d141 100644 (file)
--- 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());
+
         }
     }