Migrate HwVTEPTunnelStateListener to use the new listeners

- Code simplification by using lambdas
- Other minor changes

Note: HwvtepAbstractDataTreeChangeListener might be removed, once
verified that is not used elsewhere, in a separate commit.

Change-Id: I686f00272fe4888cc1b00db0710248ade7313220
Signed-off-by: David Suarez <david.suarez.fuentes@gmail.com>

diff --git a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/HwVTEPTunnelsStateListener.java b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/HwVTEPTunnelsStateListener.java
index 650be5126ba772dabd72e9bd19e3d573ce0fed7c..137bc3ddd134915e8724e46590450014c21e9c0b 100644 (file)
--- a/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/HwVTEPTunnelsStateListener.java
+++ b/interfacemanager/interfacemanager-impl/src/main/java/org/opendaylight/genius/interfacemanager/listeners/HwVTEPTunnelsStateListener.java
@@ -7,14 +7,11 @@
  */
 package org.opendaylight.genius.interfacemanager.listeners;
 
-import com.google.common.util.concurrent.ListenableFuture;
-import java.util.List;
-import java.util.concurrent.Callable;
+import javax.annotation.Nonnull;
 import javax.inject.Inject;
 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.datastoreutils.hwvtep.HwvtepAbstractDataTreeChangeListener;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunner;
 import org.opendaylight.genius.infra.ManagedNewTransactionRunnerImpl;
 import org.opendaylight.genius.interfacemanager.IfmConstants;
@@ -23,6 +20,7 @@ import org.opendaylight.genius.interfacemanager.renderer.hwvtep.statehelpers.HwV
 import org.opendaylight.genius.interfacemanager.renderer.hwvtep.statehelpers.HwVTEPInterfaceStateUpdateHelper;
 import org.opendaylight.genius.srm.RecoverableListener;
 import org.opendaylight.genius.srm.ServiceRecoveryRegistry;
+import org.opendaylight.genius.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
 import org.opendaylight.genius.utils.hwvtep.HwvtepNodeHACache;
 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.hwvtep.rev150901.PhysicalSwitchAugmentation;
@@ -35,112 +33,61 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Singleton
-public class HwVTEPTunnelsStateListener
-        extends HwvtepAbstractDataTreeChangeListener<Tunnels, HwVTEPTunnelsStateListener>
-        implements RecoverableListener {
+public class HwVTEPTunnelsStateListener extends AbstractSyncDataTreeChangeListener<Tunnels> implements
+        RecoverableListener {
+
     private static final Logger LOG = LoggerFactory.getLogger(HwVTEPTunnelsStateListener.class);
 
     private final ManagedNewTransactionRunner txRunner;
     private final JobCoordinator coordinator;
-    private final DataBroker dataBroker;
 
     @Inject
-    public HwVTEPTunnelsStateListener(final DataBroker dataBroker, final JobCoordinator coordinator,
-                                      final InterfaceServiceRecoveryHandler interfaceServiceRecoveryHandler,
-                                      final ServiceRecoveryRegistry serviceRecoveryRegistry,
-                                      final HwvtepNodeHACache hwvtepNodeHACache) {
-        super(Tunnels.class, HwVTEPTunnelsStateListener.class, hwvtepNodeHACache);
+    public HwVTEPTunnelsStateListener(DataBroker dataBroker,
+                                      JobCoordinator coordinator,
+                                      InterfaceServiceRecoveryHandler interfaceServiceRecoveryHandler,
+                                      ServiceRecoveryRegistry serviceRecoveryRegistry,
+                                      HwvtepNodeHACache hwvtepNodeHACache) {
+        super(dataBroker, LogicalDatastoreType.OPERATIONAL,
+              InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class)
+                      .augmentation(PhysicalSwitchAugmentation.class).child(Tunnels.class).build());
         this.txRunner = new ManagedNewTransactionRunnerImpl(dataBroker);
         this.coordinator = coordinator;
-        this.dataBroker = dataBroker;
         registerListener();
         serviceRecoveryRegistry.addRecoverableListener(interfaceServiceRecoveryHandler.buildServiceRegistryKey(),
                 this);
     }
 
     @Override
-    public void registerListener() {
-        this.registerListener(LogicalDatastoreType.OPERATIONAL, dataBroker);
-    }
-
-    @Override
-    protected InstanceIdentifier<Tunnels> getWildCardPath() {
-        return InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class)
-                .augmentation(PhysicalSwitchAugmentation.class).child(Tunnels.class).build();
+    public void remove(@Nonnull InstanceIdentifier<Tunnels> instanceIdentifier, @Nonnull Tunnels tunnel) {
+        LOG.debug("Received Remove DataChange Notification for identifier: {}, physicalSwitchAugmentation: {}",
+                  instanceIdentifier, tunnel);
+        coordinator.enqueueJob(tunnel.getTunnelUuid().getValue(), () -> HwVTEPInterfaceStateRemoveHelper
+                .removeExternalTunnel(txRunner, instanceIdentifier), IfmConstants.JOB_MAX_RETRIES);
     }
 
     @Override
-    protected HwVTEPTunnelsStateListener getDataTreeChangeListener() {
-        return HwVTEPTunnelsStateListener.this;
+    public void update(@Nonnull InstanceIdentifier<Tunnels> instanceIdentifier, @Nonnull Tunnels tunnelOld,
+                       @Nonnull Tunnels tunnelNew) {
+        LOG.debug("Received Update Tunnel Update Notification for identifier: {}", instanceIdentifier);
+        coordinator.enqueueJob(tunnelNew.getTunnelUuid().getValue(), () -> HwVTEPInterfaceStateUpdateHelper
+                .updatePhysicalSwitch(txRunner, instanceIdentifier, tunnelOld), IfmConstants.JOB_MAX_RETRIES);
     }
 
     @Override
-    protected void removed(InstanceIdentifier<Tunnels> identifier, Tunnels tunnel) {
-        LOG.debug("Received Remove DataChange Notification for identifier: {}, physicalSwitchAugmentation: {}",
-                identifier, tunnel);
-        RendererStateRemoveWorker rendererStateRemoveWorker = new RendererStateRemoveWorker(identifier);
-        coordinator.enqueueJob(tunnel.getTunnelUuid().getValue(), rendererStateRemoveWorker,
-                IfmConstants.JOB_MAX_RETRIES);
+    public void add(@Nonnull InstanceIdentifier<Tunnels> instanceIdentifier, @Nonnull Tunnels tunnelNew) {
+        LOG.debug("Received Add DataChange Notification for identifier: {}, tunnels: {}", instanceIdentifier,
+                  tunnelNew);
+        coordinator.enqueueJob(tunnelNew.getTunnelUuid().getValue(), () -> HwVTEPInterfaceStateUpdateHelper
+                .startBfdMonitoring(txRunner, instanceIdentifier, tunnelNew), IfmConstants.JOB_MAX_RETRIES);
     }
 
     @Override
-    protected void updated(InstanceIdentifier<Tunnels> identifier, Tunnels tunnelOld,
-                           Tunnels tunnelNew) {
-        LOG.debug("Received Update Tunnel Update Notification for identifier: {}", identifier);
-        RendererStateUpdateWorker rendererStateUpdateWorker =
-                new RendererStateUpdateWorker(identifier, tunnelOld);
-        coordinator.enqueueJob(tunnelNew.getTunnelUuid().getValue(), rendererStateUpdateWorker,
-                IfmConstants.JOB_MAX_RETRIES);
+    public void registerListener() {
+        super.register();
     }
 
     @Override
-    protected void added(InstanceIdentifier<Tunnels> identifier, Tunnels tunnelNew) {
-        LOG.debug("Received Add DataChange Notification for identifier: {}, tunnels: {}", identifier, tunnelNew);
-        RendererStateAddWorker rendererStateAddWorker = new RendererStateAddWorker(identifier, tunnelNew);
-        coordinator.enqueueJob(tunnelNew.getTunnelUuid().getValue(), rendererStateAddWorker,
-                IfmConstants.JOB_MAX_RETRIES);
-    }
-
-    private class RendererStateUpdateWorker implements Callable<List<ListenableFuture<Void>>> {
-        InstanceIdentifier<Tunnels> instanceIdentifier;
-        Tunnels tunnelsOld;
-
-        RendererStateUpdateWorker(InstanceIdentifier<Tunnels> instanceIdentifier, Tunnels tunnelsOld) {
-            this.instanceIdentifier = instanceIdentifier;
-            this.tunnelsOld = tunnelsOld;
-        }
-
-        @Override
-        public List<ListenableFuture<Void>> call() {
-            return HwVTEPInterfaceStateUpdateHelper.updatePhysicalSwitch(txRunner, instanceIdentifier, tunnelsOld);
-        }
-    }
-
-    private class RendererStateAddWorker implements Callable<List<ListenableFuture<Void>>> {
-        InstanceIdentifier<Tunnels> instanceIdentifier;
-        Tunnels tunnelsNew;
-
-        RendererStateAddWorker(InstanceIdentifier<Tunnels> instanceIdentifier, Tunnels tunnelsNew) {
-            this.instanceIdentifier = instanceIdentifier;
-            this.tunnelsNew = tunnelsNew;
-        }
-
-        @Override
-        public List<ListenableFuture<Void>> call() {
-            return HwVTEPInterfaceStateUpdateHelper.startBfdMonitoring(txRunner, instanceIdentifier, tunnelsNew);
-        }
-    }
-
-    private class RendererStateRemoveWorker implements Callable<List<ListenableFuture<Void>>> {
-        InstanceIdentifier<Tunnels> instanceIdentifier;
-
-        RendererStateRemoveWorker(InstanceIdentifier<Tunnels> instanceIdentifier) {
-            this.instanceIdentifier = instanceIdentifier;
-        }
-
-        @Override
-        public List<ListenableFuture<Void>> call() {
-            return HwVTEPInterfaceStateRemoveHelper.removeExternalTunnel(txRunner, instanceIdentifier);
-        }
+    public void deregisterListener() {
+        close();
     }
 }