Migrate the last two listeners in itm-impl module

Migrate the last two listeners in itm-impl module to use the new
listeners framework.

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

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorChangeListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorChangeListener.java
index 49f923d08635612a3182bb6d7b1abaad345773cb..66cb25407caef29d387425ebc915d2dc33e05941 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorChangeListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorChangeListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
+ * Copyright (c) 2016, 2018 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
@@ -8,16 +8,15 @@
 package org.opendaylight.genius.itm.listeners;
 
 import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
+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.AsyncDataTreeChangeListenerBase;
 import org.opendaylight.genius.itm.confighelpers.ItmMonitorToggleWorker;
 import org.opendaylight.genius.itm.globals.ITMConstants;
 import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.genius.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams;
@@ -29,7 +28,7 @@ import org.slf4j.LoggerFactory;
 
 @Singleton
 public class TunnelMonitorChangeListener
-        extends AsyncDataTreeChangeListenerBase<TunnelMonitorParams, TunnelMonitorChangeListener> {
+        extends AbstractSyncDataTreeChangeListener<TunnelMonitorParams> {
 
     private static final Logger LOG = LoggerFactory.getLogger(TunnelMonitorChangeListener.class);
 
@@ -37,30 +36,15 @@ public class TunnelMonitorChangeListener
     private final JobCoordinator jobCoordinator;
 
     @Inject
-    public TunnelMonitorChangeListener(final DataBroker dataBroker, JobCoordinator jobCoordinator) {
-        super(TunnelMonitorParams.class, TunnelMonitorChangeListener.class);
+    public TunnelMonitorChangeListener(DataBroker dataBroker, JobCoordinator jobCoordinator) {
+        super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(TunnelMonitorParams.class));
         this.broker = dataBroker;
         this.jobCoordinator = jobCoordinator;
     }
 
-    @PostConstruct
-    public void start() throws  Exception {
-        registerListener(LogicalDatastoreType.CONFIGURATION, this.broker);
-        LOG.info("Tunnel Monitor listeners Started");
-    }
-
     @Override
-    @PreDestroy
-    public void close() {
-        LOG.info("Tunnel Monitor listeners Closed");
-    }
-
-    @Override protected InstanceIdentifier<TunnelMonitorParams> getWildCardPath() {
-        return InstanceIdentifier.create(TunnelMonitorParams.class);
-    }
-
-    @Override
-    protected void remove(InstanceIdentifier<TunnelMonitorParams> key, TunnelMonitorParams dataObjectModification) {
+    public void remove(@Nonnull InstanceIdentifier<TunnelMonitorParams> instanceIdentifier,
+                       @Nonnull TunnelMonitorParams dataObjectModification) {
         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
         Optional<TransportZones> transportZonesOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
                 path, broker);
@@ -81,9 +65,9 @@ public class TunnelMonitorChangeListener
     }
 
     @Override
-    protected void update(InstanceIdentifier<TunnelMonitorParams> key,
-                                    TunnelMonitorParams dataObjectModificationBefore,
-                                    TunnelMonitorParams dataObjectModificationAfter) {
+    public void update(@Nonnull InstanceIdentifier<TunnelMonitorParams> instanceIdentifier,
+                       @Nonnull TunnelMonitorParams dataObjectModificationBefore,
+                       @Nonnull TunnelMonitorParams dataObjectModificationAfter) {
         LOG.debug("update TunnelMonitorChangeListener called with {}",dataObjectModificationAfter.isEnabled());
         Class<? extends TunnelMonitoringTypeBase> monitorProtocolBefore =
                 dataObjectModificationBefore.getMonitorProtocol();
@@ -117,7 +101,8 @@ public class TunnelMonitorChangeListener
     }
 
     @Override
-    protected void add(InstanceIdentifier<TunnelMonitorParams> key, TunnelMonitorParams dataObjectModification) {
+    public void add(@Nonnull InstanceIdentifier<TunnelMonitorParams> instanceIdentifier,
+                    @Nonnull TunnelMonitorParams dataObjectModification) {
         LOG.debug("Add - TunnelMonitorToggleWorker with Enable = {}, MonitorProtocol = {}",
                 dataObjectModification.isEnabled(), dataObjectModification.getMonitorProtocol());
         Class<? extends TunnelMonitoringTypeBase> monitorProtocol = dataObjectModification.getMonitorProtocol();
@@ -139,8 +124,4 @@ public class TunnelMonitorChangeListener
             }
         }
     }
-
-    @Override protected TunnelMonitorChangeListener getDataTreeChangeListener() {
-        return TunnelMonitorChangeListener.this;
-    }
 }

diff --git a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java
index 30e7509242be06b334ba2fd0661e662dae56e68c..f0625a049e14d83e7c7d84b4505bbe8870faf376 100644 (file)
--- a/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java
+++ b/itm/itm-impl/src/main/java/org/opendaylight/genius/itm/listeners/TunnelMonitorIntervalListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016, 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
+ * Copyright (c) 2016, 2018 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
@@ -8,15 +8,14 @@
 package org.opendaylight.genius.itm.listeners;
 
 import com.google.common.base.Optional;
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
+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.AsyncDataTreeChangeListenerBase;
 import org.opendaylight.genius.itm.confighelpers.ItmMonitorIntervalWorker;
 import org.opendaylight.genius.itm.impl.ItmUtils;
+import org.opendaylight.genius.tools.mdsal.listener.AbstractSyncDataTreeChangeListener;
 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
@@ -26,8 +25,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Singleton
-public class TunnelMonitorIntervalListener
-        extends AsyncDataTreeChangeListenerBase<TunnelMonitorInterval, TunnelMonitorIntervalListener> {
+public class TunnelMonitorIntervalListener extends AbstractSyncDataTreeChangeListener<TunnelMonitorInterval> {
 
     private static final Logger LOG = LoggerFactory.getLogger(TunnelMonitorIntervalListener.class);
 
@@ -36,85 +34,71 @@ public class TunnelMonitorIntervalListener
 
     @Inject
     public TunnelMonitorIntervalListener(DataBroker dataBroker, JobCoordinator jobCoordinator) {
-        super(TunnelMonitorInterval.class, TunnelMonitorIntervalListener.class);
+        super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(TunnelMonitorInterval.class));
         this.broker = dataBroker;
         this.jobCoordinator = jobCoordinator;
     }
 
-    @PostConstruct
-    public void start() {
-        registerListener(LogicalDatastoreType.CONFIGURATION, this.broker);
-        LOG.info("TunnelMonitorIntervalListener Started");
-    }
-
-    @Override
-    @PreDestroy
-    public void close() {
-        LOG.info("TunnelMonitorIntervalListener Closed");
-    }
-
-    @Override protected InstanceIdentifier<TunnelMonitorInterval> getWildCardPath() {
-        return InstanceIdentifier.create(TunnelMonitorInterval.class);
-    }
-
     @Override
-    protected void remove(InstanceIdentifier<TunnelMonitorInterval> key, TunnelMonitorInterval dataObjectModification) {
-        LOG.debug("remove TunnelMonitorIntervalListener called with {}",dataObjectModification.getInterval());
+    public void remove(@Nonnull InstanceIdentifier<TunnelMonitorInterval> instanceIdentifier,
+                       @Nonnull TunnelMonitorInterval dataObjectModification) {
+        LOG.debug("remove TunnelMonitorIntervalListener called with {}", dataObjectModification.getInterval());
         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
-        Optional<TransportZones> transportZonesOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
-                path, broker);
+        Optional<TransportZones> transportZonesOptional = ItmUtils
+                .read(LogicalDatastoreType.CONFIGURATION, path, broker);
         if (transportZonesOptional.isPresent()) {
             TransportZones tzones = transportZonesOptional.get();
             for (TransportZone tzone : tzones.getTransportZone()) {
                 //if you remove configuration, the last configured interval is only set i.e no change
-                LOG.debug("Remove:Calling TunnelMonitorIntervalWorker with tzone = {} and {}",
-                        tzone.getZoneName(),dataObjectModification.getInterval());
+                LOG.debug("Remove:Calling TunnelMonitorIntervalWorker with tzone = {} and {}", tzone.getZoneName(),
+                          dataObjectModification.getInterval());
                 ItmMonitorIntervalWorker toggleWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
-                        dataObjectModification.getInterval(), broker);
+                                                                                     dataObjectModification
+                                                                                             .getInterval(), broker);
                 jobCoordinator.enqueueJob(tzone.getZoneName(), toggleWorker);
             }
         }
     }
 
-    @Override protected void update(InstanceIdentifier<TunnelMonitorInterval> key,
-                                    TunnelMonitorInterval dataObjectModificationBefore,
-                                    TunnelMonitorInterval dataObjectModificationAfter) {
-        LOG.debug("update TunnelMonitorIntervalListener called with {}",dataObjectModificationAfter.getInterval());
+    @Override
+    public void update(@Nonnull InstanceIdentifier<TunnelMonitorInterval> instanceIdentifier,
+                       @Nonnull TunnelMonitorInterval dataObjectModificationBefore,
+                       @Nonnull TunnelMonitorInterval dataObjectModificationAfter) {
+        LOG.debug("update TunnelMonitorIntervalListener called with {}", dataObjectModificationAfter.getInterval());
         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
-        Optional<TransportZones> transportZonesOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
-                path, broker);
+        Optional<TransportZones> transportZonesOptional = ItmUtils
+                .read(LogicalDatastoreType.CONFIGURATION, path, broker);
         if (transportZonesOptional.isPresent()) {
             TransportZones tzones = transportZonesOptional.get();
             for (TransportZone tzone : tzones.getTransportZone()) {
-                LOG.debug("Update:Calling TunnelMonitorIntervalWorker with tzone = {} and {}",
-                        tzone.getZoneName(),dataObjectModificationAfter.getInterval());
+                LOG.debug("Update:Calling TunnelMonitorIntervalWorker with tzone = {} and {}", tzone.getZoneName(),
+                          dataObjectModificationAfter.getInterval());
                 ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
-                        dataObjectModificationAfter.getInterval(), broker);
+                                                                                       dataObjectModificationAfter
+                                                                                               .getInterval(), broker);
                 jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
             }
         }
     }
 
     @Override
-    protected void add(InstanceIdentifier<TunnelMonitorInterval> key, TunnelMonitorInterval dataObjectModification) {
-        LOG.debug("Add TunnelMonitorIntervalListener called with {}",dataObjectModification.getInterval());
+    public void add(@Nonnull InstanceIdentifier<TunnelMonitorInterval> instanceIdentifier,
+                    @Nonnull TunnelMonitorInterval dataObjectModification) {
+        LOG.debug("Add TunnelMonitorIntervalListener called with {}", dataObjectModification.getInterval());
         InstanceIdentifier<TransportZones> path = InstanceIdentifier.builder(TransportZones.class).build();
-        Optional<TransportZones> transportZonesOptional = ItmUtils.read(LogicalDatastoreType.CONFIGURATION,
-                path, broker);
+        Optional<TransportZones> transportZonesOptional = ItmUtils
+                .read(LogicalDatastoreType.CONFIGURATION, path, broker);
         if (transportZonesOptional.isPresent()) {
             TransportZones tzones = transportZonesOptional.get();
             for (TransportZone tzone : tzones.getTransportZone()) {
-                LOG.debug("Add:Calling TunnelMonitorIntervalWorker with tzone = {} and {}",
-                        tzone.getZoneName(),dataObjectModification.getInterval());
+                LOG.debug("Add:Calling TunnelMonitorIntervalWorker with tzone = {} and {}", tzone.getZoneName(),
+                          dataObjectModification.getInterval());
                 ItmMonitorIntervalWorker intervalWorker = new ItmMonitorIntervalWorker(tzone.getZoneName(),
-                        dataObjectModification.getInterval(), broker);
+                                                                                       dataObjectModification
+                                                                                               .getInterval(), broker);
                 //conversion to milliseconds done while writing to i/f-mgr config DS
                 jobCoordinator.enqueueJob(tzone.getZoneName(), intervalWorker);
             }
         }
     }
-
-    @Override protected TunnelMonitorIntervalListener getDataTreeChangeListener() {
-        return TunnelMonitorIntervalListener.this;
-    }
 }