NETVIRT-1630 migrate to md-sal APIs

[netvirt.git] / qosservice / impl / src / main / java / org / opendaylight / netvirt / qosservice / QosNeutronNetworkChangeListener.java

diff --git a/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java b/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java
index 56cd9f7b43d5c7908a2de04ea6b6be6626bbb448..8febbe0a255977451dad774a640cb2be38e3c810 100644 (file)
--- a/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java
+++ b/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java
@@ -7,15 +7,17 @@
  */
 package org.opendaylight.netvirt.qosservice;
 
-import javax.annotation.PostConstruct;
+import java.util.Objects;
+import javax.annotation.PreDestroy;
 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.AsyncClusteredDataTreeChangeListenerBase;
-import org.opendaylight.genius.srm.RecoverableListener;
-import org.opendaylight.genius.srm.ServiceRecoveryRegistry;
+import org.opendaylight.infrautils.utils.concurrent.Executors;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
 import org.opendaylight.netvirt.qosservice.recovery.QosServiceRecoveryHandler;
+import org.opendaylight.serviceutils.srm.RecoverableListener;
+import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
+import org.opendaylight.serviceutils.tools.listener.AbstractClusteredAsyncDataTreeChangeListener;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.ext.rev160613.QosNetworkExtension;
@@ -25,108 +27,84 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 @Singleton
-public class QosNeutronNetworkChangeListener extends AsyncClusteredDataTreeChangeListenerBase<Network,
-        QosNeutronNetworkChangeListener> implements RecoverableListener {
+public class QosNeutronNetworkChangeListener extends AbstractClusteredAsyncDataTreeChangeListener<Network>
+        implements RecoverableListener {
     private static final Logger LOG = LoggerFactory.getLogger(QosNeutronNetworkChangeListener.class);
     private final DataBroker dataBroker;
-    private final QosAlertManager qosAlertManager;
     private final QosNeutronUtils qosNeutronUtils;
 
     @Inject
-    public QosNeutronNetworkChangeListener(final DataBroker dataBroker, final QosAlertManager qosAlertManager,
+    public QosNeutronNetworkChangeListener(final DataBroker dataBroker,
                                            final QosNeutronUtils qosNeutronUtils,
                                            final ServiceRecoveryRegistry serviceRecoveryRegistry,
                                            final QosServiceRecoveryHandler qosServiceRecoveryHandler) {
-        super(Network.class, QosNeutronNetworkChangeListener.class);
+        super(dataBroker, LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Neutron.class)
+                .child(Networks.class).child(Network.class),
+                Executors.newListeningSingleThreadExecutor("QosNeutronNetworkChangeListener", LOG));
         this.dataBroker = dataBroker;
-        this.qosAlertManager = qosAlertManager;
         this.qosNeutronUtils = qosNeutronUtils;
         serviceRecoveryRegistry.addRecoverableListener(qosServiceRecoveryHandler.buildServiceRegistryKey(),
                 this);
-        LOG.debug("{} created",  getClass().getSimpleName());
+        LOG.trace("{} created",  getClass().getSimpleName());
     }
 
-    @PostConstruct
     public void init() {
-        registerListener();
-        LOG.debug("{} init and registerListener done", getClass().getSimpleName());
+        LOG.trace("{} init and registerListener done", getClass().getSimpleName());
     }
 
     @Override
-    public void registerListener() {
-        registerListener(LogicalDatastoreType.CONFIGURATION, dataBroker);
+    @PreDestroy
+    public void close() {
+        super.close();
+        Executors.shutdownAndAwaitTermination(getExecutorService());
     }
 
     @Override
-    protected InstanceIdentifier<Network> getWildCardPath() {
-        return InstanceIdentifier.create(Neutron.class).child(Networks.class).child(Network.class);
+    public void registerListener() {
+        super.register();
     }
 
     @Override
-    protected QosNeutronNetworkChangeListener getDataTreeChangeListener() {
-        return QosNeutronNetworkChangeListener.this;
+    public void deregisterListener() {
+        super.close();
     }
 
     @Override
-    protected void remove(InstanceIdentifier<Network> instanceIdentifier, Network network) {
+    public void remove(InstanceIdentifier<Network> instanceIdentifier, Network network) {
         qosNeutronUtils.removeFromNetworkCache(network);
-        if (qosNeutronUtils.hasBandwidthLimitRule(network)) {
-            qosAlertManager.removeFromQosAlertCache(network);
-        }
     }
 
     @Override
-    protected void update(InstanceIdentifier<Network> instanceIdentifier, Network original, Network update) {
+    public void update(InstanceIdentifier<Network> instanceIdentifier, Network original, Network update) {
         qosNeutronUtils.addToNetworkCache(update);
 
-        QosNetworkExtension updateQos = update.getAugmentation(QosNetworkExtension.class);
-        QosNetworkExtension originalQos = original.getAugmentation(QosNetworkExtension.class);
+        QosNetworkExtension updateQos = update.augmentation(QosNetworkExtension.class);
+        QosNetworkExtension originalQos = original.augmentation(QosNetworkExtension.class);
         if (originalQos == null && updateQos != null) {
             // qosservice policy add
             qosNeutronUtils.addToQosNetworksCache(updateQos.getQosPolicyId(), update);
             qosNeutronUtils.handleNeutronNetworkQosUpdate(update, updateQos.getQosPolicyId());
-            if (qosNeutronUtils.hasBandwidthLimitRule(update)) {
-                qosAlertManager.addToQosAlertCache(update);
-            }
         } else if (originalQos != null && updateQos != null
-                && !originalQos.getQosPolicyId().equals(updateQos.getQosPolicyId())) {
-
+                && !Objects.equals(originalQos.getQosPolicyId(), updateQos.getQosPolicyId())) {
             // qosservice policy update
-
             qosNeutronUtils.removeFromQosNetworksCache(originalQos.getQosPolicyId(), original);
             qosNeutronUtils.addToQosNetworksCache(updateQos.getQosPolicyId(), update);
             qosNeutronUtils.handleNeutronNetworkQosUpdate(update, updateQos.getQosPolicyId());
-
-            if (qosNeutronUtils.hasBandwidthLimitRule(original)
-                                             && !qosNeutronUtils.hasBandwidthLimitRule(update)) {
-                qosAlertManager.removeFromQosAlertCache(original);
-            } else if (!qosNeutronUtils.hasBandwidthLimitRule(original)
-                                              && qosNeutronUtils.hasBandwidthLimitRule(update)) {
-                qosAlertManager.addToQosAlertCache(update);
-            }
-
         } else if (originalQos != null && updateQos == null) {
             // qosservice policy delete
-            if (qosNeutronUtils.hasBandwidthLimitRule(original)) {
-                qosAlertManager.removeFromQosAlertCache(original);
-            }
             qosNeutronUtils.handleNeutronNetworkQosRemove(original, originalQos.getQosPolicyId());
             qosNeutronUtils.removeFromQosNetworksCache(originalQos.getQosPolicyId(), original);
         }
     }
 
     @Override
-    protected void add(InstanceIdentifier<Network> instanceIdentifier, Network network) {
+    public void add(InstanceIdentifier<Network> instanceIdentifier, Network network) {
         qosNeutronUtils.addToNetworkCache(network);
 
-        QosNetworkExtension networkQos = network.getAugmentation(QosNetworkExtension.class);
+        QosNetworkExtension networkQos = network.augmentation(QosNetworkExtension.class);
         if (networkQos != null) {
             qosNeutronUtils.addToQosNetworksCache(networkQos.getQosPolicyId(), network);
             qosNeutronUtils.handleNeutronNetworkQosUpdate(network, networkQos.getQosPolicyId());
-            if (qosNeutronUtils.hasBandwidthLimitRule(network)) {
-                qosAlertManager.addToQosAlertCache(network);
-            }
-
         }
     }
 }