Renaming workers in itm listeners

Change-Id: Ib4ad9499cd47a588741a7f8481093471fa9f733f
Signed-off-by: Edw7n <n.edwin.anthony@ericsson.com>

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java
index 6e1e5e5ca2fcb27e6772798f7e6440eba47d2cb1..2f1325fc9419cfe956415cdcc77b4ab1c3d1c3aa 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TerminationPointStateListener.java
@@ -78,7 +78,7 @@ public class TerminationPointStateListener
             LOG.debug("Received remove DataChange Notification for ovsdb termination point {}", tpOld.getName());
             if (tpOld.getInterfaceBfdStatus() != null) {
                 LOG.debug("Received termination point removed notification with bfd status values {}", tpOld.getName());
-                RendererStateRemoveWorker rendererStateRemoveWorker = new RendererStateRemoveWorker(tpOld);
+                RendererTunnelStateRemoveWorker rendererStateRemoveWorker = new RendererTunnelStateRemoveWorker(tpOld);
                 coordinator.enqueueJob(tpOld.getName(), rendererStateRemoveWorker);
             }
         }
@@ -95,7 +95,7 @@ public class TerminationPointStateListener
                     || DirectTunnelUtils.ifBfdStatusNotEqual(tpOld, tpNew)) {
                 LOG.info("Bfd Status changed for ovsdb termination point identifier: {},  old: {}, new: {}",
                         identifier, tpOld, tpNew);
-                RendererStateUpdateWorker rendererStateAddWorker = new RendererStateUpdateWorker(tpNew);
+                RendererTunnelStateUpdateWorker rendererStateAddWorker = new RendererTunnelStateUpdateWorker(tpNew);
                 coordinator.enqueueJob(tpNew.getName(), rendererStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
             }
         }
@@ -109,7 +109,7 @@ public class TerminationPointStateListener
             LOG.debug("Received add DataChange Notification for ovsdb termination point {}", tpNew.getName());
             if (tpNew.getInterfaceBfdStatus() != null  && !tpNew.getInterfaceBfdStatus().isEmpty()) {
                 LOG.debug("Received termination point added notification with bfd status values {}", tpNew.getName());
-                RendererStateUpdateWorker rendererStateUpdateWorker = new RendererStateUpdateWorker(tpNew);
+                RendererTunnelStateUpdateWorker rendererStateUpdateWorker = new RendererTunnelStateUpdateWorker(tpNew);
                 coordinator.enqueueJob(tpNew.getName(), rendererStateUpdateWorker, ITMConstants.JOB_MAX_RETRIES);
             }
         }
@@ -170,10 +170,10 @@ public class TerminationPointStateListener
         transaction.merge(LogicalDatastoreType.OPERATIONAL, stateTnlII, stateTnlBuilder.build(), false);
     }
 
-    private class RendererStateUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
+    private class RendererTunnelStateUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
         private final OvsdbTerminationPointAugmentation terminationPointNew;
 
-        RendererStateUpdateWorker(OvsdbTerminationPointAugmentation tpNew) {
+        RendererTunnelStateUpdateWorker(OvsdbTerminationPointAugmentation tpNew) {
             this.terminationPointNew = tpNew;
         }
 
@@ -185,10 +185,10 @@ public class TerminationPointStateListener
         }
     }
 
-    private class RendererStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
+    private class RendererTunnelStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
         private final OvsdbTerminationPointAugmentation terminationPointOld;
 
-        RendererStateRemoveWorker(OvsdbTerminationPointAugmentation tpNew) {
+        RendererTunnelStateRemoveWorker(OvsdbTerminationPointAugmentation tpNew) {
             this.terminationPointOld = tpNew;
         }
 

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 4f033de4330e39d513d42f9f9fedf9d6b6a92a81..d8ca326f2c1b4b21a26feb6107c6d5fafb59dc5c 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
@@ -115,7 +115,7 @@ public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<Flo
     private void remove(NodeConnectorId nodeConnectorId,
                         FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
         LOG.debug("InterfaceInventoryState REMOVE for {}", portName);
-        InterfaceStateRemoveWorker portStateRemoveWorker = new InterfaceStateRemoveWorker(nodeConnectorId,
+        TunnelInterfaceStateRemoveWorker portStateRemoveWorker = new TunnelInterfaceStateRemoveWorker(nodeConnectorId,
                 fcNodeConnectorNew, portName);
         coordinator.enqueueJob(portName, portStateRemoveWorker, ITMConstants.JOB_MAX_RETRIES);
     }
@@ -137,8 +137,8 @@ public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<Flo
         }
         LOG.debug("Received NodeConnector Update Event: {}, {}, {}", key, fcNodeConnectorOld, fcNodeConnectorNew);
 
-        InterfaceStateUpdateWorker portStateUpdateWorker = new InterfaceStateUpdateWorker(key, fcNodeConnectorOld,
-                fcNodeConnectorNew, portName);
+        TunnelInterfaceStateUpdateWorker portStateUpdateWorker =
+                new TunnelInterfaceStateUpdateWorker(key, fcNodeConnectorOld, fcNodeConnectorNew, portName);
         coordinator.enqueueJob(portName, portStateUpdateWorker, ITMConstants.JOB_MAX_RETRIES);
     }
 
@@ -166,13 +166,11 @@ public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<Flo
         }
 
         LOG.debug("Received NodeConnector Add Event: {}, {}", key, fcNodeConnectorNew);
-        if (DirectTunnelUtils.TUNNEL_PORT_PREDICATE.test(portName) && dpnTepStateCache.isInternal(portName)) {
-            //NodeConnectorId nodeConnectorId =
-            // InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
-            InterfaceStateAddWorker ifStateAddWorker = new InterfaceStateAddWorker(key,
-                    fcNodeConnectorNew, portName);
-            coordinator.enqueueJob(portName, ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
-        }
+        // NodeConnectorId nodeConnectorId =
+        // InstanceIdentifier.keyOf(key.firstIdentifierOf(NodeConnector.class)).getId();
+        TunnelInterfaceStateAddWorker ifStateAddWorker =
+                new TunnelInterfaceStateAddWorker(key, fcNodeConnectorNew, portName);
+        coordinator.enqueueJob(portName, ifStateAddWorker, ITMConstants.JOB_MAX_RETRIES);
     }
 
     private List<ListenableFuture<Void>> updateState(String interfaceName,
@@ -306,13 +304,13 @@ public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<Flo
         return futures;
     }
 
-    private class InterfaceStateAddWorker implements Callable {
+    private class TunnelInterfaceStateAddWorker implements Callable {
         private final InstanceIdentifier<FlowCapableNodeConnector> key;
         private final FlowCapableNodeConnector fcNodeConnectorNew;
         private final String interfaceName;
 
-        InterfaceStateAddWorker(InstanceIdentifier<FlowCapableNodeConnector> key,
-                                FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
+        TunnelInterfaceStateAddWorker(InstanceIdentifier<FlowCapableNodeConnector> key,
+                                      FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
             this.key = key;
             this.fcNodeConnectorNew = fcNodeConnectorNew;
             this.interfaceName = portName;
@@ -327,20 +325,20 @@ public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<Flo
 
         @Override
         public String toString() {
-            return "InterfaceStateAddWorker{fcNodeConnectorIdentifier=" + key + ", fcNodeConnectorNew="
+            return "TunnelInterfaceStateAddWorker{fcNodeConnectorIdentifier=" + key + ", fcNodeConnectorNew="
                     + fcNodeConnectorNew + ", interfaceName='" + interfaceName + '\'' + '}';
         }
     }
 
-    private class InterfaceStateUpdateWorker implements Callable {
+    private class TunnelInterfaceStateUpdateWorker implements Callable {
         private final InstanceIdentifier<FlowCapableNodeConnector> key;
         private final FlowCapableNodeConnector fcNodeConnectorOld;
         private final FlowCapableNodeConnector fcNodeConnectorNew;
         private final String interfaceName;
 
-        InterfaceStateUpdateWorker(InstanceIdentifier<FlowCapableNodeConnector> key,
-                                   FlowCapableNodeConnector fcNodeConnectorOld,
-                                   FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
+        TunnelInterfaceStateUpdateWorker(InstanceIdentifier<FlowCapableNodeConnector> key,
+                                         FlowCapableNodeConnector fcNodeConnectorOld,
+                                         FlowCapableNodeConnector fcNodeConnectorNew, String portName) {
             this.key = key;
             this.fcNodeConnectorOld = fcNodeConnectorOld;
             this.fcNodeConnectorNew = fcNodeConnectorNew;
@@ -356,18 +354,19 @@ public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<Flo
 
         @Override
         public String toString() {
-            return "InterfaceStateUpdateWorker{key=" + key + ", fcNodeConnectorOld=" + fcNodeConnectorOld
+            return "TunnelInterfaceStateUpdateWorker{key=" + key + ", fcNodeConnectorOld=" + fcNodeConnectorOld
                     + ", fcNodeConnectorNew=" + fcNodeConnectorNew + ", interfaceName='" + interfaceName + '\'' + '}';
         }
     }
 
-    private class InterfaceStateRemoveWorker implements Callable {
+    private class TunnelInterfaceStateRemoveWorker implements Callable {
         private final NodeConnectorId nodeConnectorId;
         private final FlowCapableNodeConnector flowCapableNodeConnector;
         private final String interfaceName;
 
-        InterfaceStateRemoveWorker(NodeConnectorId nodeConnectorId, FlowCapableNodeConnector flowCapableNodeConnector,
-                                   String interfaceName) {
+        TunnelInterfaceStateRemoveWorker(NodeConnectorId nodeConnectorId,
+                                         FlowCapableNodeConnector flowCapableNodeConnector,
+                                         String interfaceName) {
             this.nodeConnectorId = nodeConnectorId;
             this.flowCapableNodeConnector = flowCapableNodeConnector;
             this.interfaceName = interfaceName;
@@ -382,7 +381,7 @@ public class TunnelInventoryStateListener extends AbstractTunnelListenerBase<Flo
 
         @Override
         public String toString() {
-            return "InterfaceStateRemoveWorker{nodeConnectorId=" + nodeConnectorId + ", fcNodeConnector"
+            return "TunnelInterfaceStateRemoveWorker{nodeConnectorId=" + nodeConnectorId + ", fcNodeConnector"
                     + flowCapableNodeConnector + ", interfaceName='" + interfaceName + '\'' + '}';
         }
     }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java
index 61b941ea1191095b60dcfdd3c6b5c1583f44e3f1..13ddf7cede15b7e006dc123dd81aa1b5b992e522 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/itmdirecttunnels/listeners/TunnelTopologyStateListener.java
@@ -83,7 +83,8 @@ public class TunnelTopologyStateListener extends AbstractTunnelListenerBase<Ovsd
         if (entityOwner()) {
             LOG.debug("Received Remove DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
                     identifier, bridgeOld);
-            RendererStateRemoveWorker rendererStateRemoveWorker = new RendererStateRemoveWorker(identifier, bridgeOld);
+            TunnelRendererStateRemoveWorker rendererStateRemoveWorker =
+                    new TunnelRendererStateRemoveWorker(identifier, bridgeOld);
             coordinator.enqueueJob(bridgeOld.getBridgeName().getValue(), rendererStateRemoveWorker,
                     ITMConstants.JOB_MAX_RETRIES);
         }
@@ -102,12 +103,13 @@ public class TunnelTopologyStateListener extends AbstractTunnelListenerBase<Ovsd
         DatapathId oldDpid = bridgeOld.getDatapathId();
         DatapathId newDpid = bridgeNew.getDatapathId();
         if (oldDpid == null && newDpid != null) {
-            RendererStateAddWorker rendererStateAddWorker = new RendererStateAddWorker(identifier, bridgeNew);
+            TunnelRendererStateAddWorker rendererStateAddWorker =
+                    new TunnelRendererStateAddWorker(identifier, bridgeNew);
             coordinator.enqueueJob(bridgeNew.getBridgeName().getValue(), rendererStateAddWorker,
                     ITMConstants.JOB_MAX_RETRIES);
         } else if (oldDpid != null && !oldDpid.equals(newDpid)) {
-            RendererStateUpdateWorker rendererStateAddWorker =
-                    new RendererStateUpdateWorker(identifier, bridgeNew, bridgeOld);
+            TunnelRendererStateUpdateWorker rendererStateAddWorker =
+                    new TunnelRendererStateUpdateWorker(identifier, bridgeNew, bridgeOld);
             coordinator.enqueueJob(bridgeNew.getBridgeName().getValue(), rendererStateAddWorker,
                     ITMConstants.JOB_MAX_RETRIES);
         }
@@ -119,7 +121,8 @@ public class TunnelTopologyStateListener extends AbstractTunnelListenerBase<Ovsd
         if (entityOwner()) {
             LOG.debug("Received Add DataChange Notification for identifier: {}, ovsdbBridgeAugmentation: {}",
                     identifier, bridgeNew);
-            RendererStateAddWorker rendererStateAddWorker = new RendererStateAddWorker(identifier, bridgeNew);
+            TunnelRendererStateAddWorker rendererStateAddWorker =
+                    new TunnelRendererStateAddWorker(identifier, bridgeNew);
             coordinator.enqueueJob(bridgeNew.getBridgeName().getValue(), rendererStateAddWorker,
                     ITMConstants.JOB_MAX_RETRIES);
         }
@@ -233,12 +236,12 @@ public class TunnelTopologyStateListener extends AbstractTunnelListenerBase<Ovsd
         }
     }
 
-    private class RendererStateAddWorker implements Callable<List<ListenableFuture<Void>>> {
+    private class TunnelRendererStateAddWorker implements Callable<List<ListenableFuture<Void>>> {
         private final InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid;
         private final OvsdbBridgeAugmentation bridgeNew;
 
-        RendererStateAddWorker(InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid,
-                               OvsdbBridgeAugmentation bridgeNew) {
+        TunnelRendererStateAddWorker(InstanceIdentifier<OvsdbBridgeAugmentation> bridgeIid,
+                                     OvsdbBridgeAugmentation bridgeNew) {
             this.bridgeIid = bridgeIid;
             this.bridgeNew = bridgeNew;
         }
@@ -269,12 +272,12 @@ public class TunnelTopologyStateListener extends AbstractTunnelListenerBase<Ovsd
         }
     }
 
-    private class RendererStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
+    private class TunnelRendererStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
         private final InstanceIdentifier<OvsdbBridgeAugmentation> instanceIdentifier;
         private final OvsdbBridgeAugmentation bridgeNew;
 
-        RendererStateRemoveWorker(InstanceIdentifier<OvsdbBridgeAugmentation> instanceIdentifier,
-                                  OvsdbBridgeAugmentation bridgeNew) {
+        TunnelRendererStateRemoveWorker(InstanceIdentifier<OvsdbBridgeAugmentation> instanceIdentifier,
+                                        OvsdbBridgeAugmentation bridgeNew) {
             this.instanceIdentifier = instanceIdentifier;
             this.bridgeNew = bridgeNew;
         }
@@ -287,13 +290,13 @@ public class TunnelTopologyStateListener extends AbstractTunnelListenerBase<Ovsd
         }
     }
 
-    private class RendererStateUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
+    private class TunnelRendererStateUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
         private final InstanceIdentifier<OvsdbBridgeAugmentation> instanceIdentifier;
         private final OvsdbBridgeAugmentation bridgeNew;
         private final OvsdbBridgeAugmentation bridgeOld;
 
-        RendererStateUpdateWorker(InstanceIdentifier<OvsdbBridgeAugmentation> instanceIdentifier,
-                                  OvsdbBridgeAugmentation bridgeNew, OvsdbBridgeAugmentation bridgeOld) {
+        TunnelRendererStateUpdateWorker(InstanceIdentifier<OvsdbBridgeAugmentation> instanceIdentifier,
+                                        OvsdbBridgeAugmentation bridgeNew, OvsdbBridgeAugmentation bridgeOld) {
             this.instanceIdentifier = instanceIdentifier;
             this.bridgeNew = bridgeNew;
             this.bridgeOld = bridgeOld;