Netvirt: Qos Alert patch4

*** patch #4 - Building Qos Alert port cache ***

This patch builds a cache of port stats data having QoS rate-limit rule applied.

A neutron port is added into the cache if -

1. Port QoS policy has bandwidth rate limit rule.
2. If port does not have QoS policy applied, then if network QoS policy
   has bandwidth rate limit rule.

Spec Review Link:
https://git.opendaylight.org/gerrit/50689

Change-Id: Iafb22bd98009b891a2ef4911ef0edf9f2ab9c767
Signed-off-by: Arun Sharma <arun.e.sharma@ericsson.com>

diff --git a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosAlertManager.java b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosAlertManager.java
index a19c8f720e69f550c68961c8b3e6a4ba98a34aef..4736600e6b30cc4ea2aeb6bc260062085ad584e5 100644 (file)
--- a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosAlertManager.java
+++ b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosAlertManager.java
@@ -11,6 +11,9 @@ package org.opendaylight.netvirt.qosservice;
 
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
+import java.math.BigInteger;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.inject.Inject;
@@ -18,9 +21,16 @@ import javax.inject.Singleton;
 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.genius.mdsalutil.MDSALUtil;
+import org.opendaylight.netvirt.neutronvpn.interfaces.INeutronVpnManager;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.direct.statistics.rev160511.OpendaylightDirectStatisticsService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.qosalert.config.rev170301.QosalertConfig;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.netvirt.qosalert.config.rev170301.QosalertConfigBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
 import org.opendaylight.yangtools.yang.binding.DataObject;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 import org.slf4j.Logger;
@@ -35,9 +45,13 @@ public final class QosAlertManager implements Runnable {
     private int pollInterval;
     private final QosalertConfig defaultConfig;
     private boolean statsPollThreadStart;
-    private final DataBroker dataBroker;
-    private final OpendaylightDirectStatisticsService odlDirectStatisticsService;
+    private static DataBroker dataBroker;
+    private static OpendaylightDirectStatisticsService odlDirectStatisticsService;
+    private static INeutronVpnManager neutronVpnManager;
     private Thread thread;
+    private static OdlInterfaceRpcService odlInterfaceRpcService;
+    private static ConcurrentHashMap<BigInteger, ConcurrentHashMap<String, QosAlertPortData>>
+                                                         qosAlertDpnPortNumberMap = new ConcurrentHashMap<>();
     private static final Logger LOG = LoggerFactory.getLogger(QosAlertManager.class);
 
     private static final FutureCallback<Void> DEFAULT_FUTURE_CALLBACK;
@@ -59,11 +73,17 @@ public final class QosAlertManager implements Runnable {
     }
 
     @Inject
-    public QosAlertManager(final DataBroker dataBroker, OpendaylightDirectStatisticsService odlDirectStatisticsService,
-                            QosalertConfig defaultConfig) {
+    public QosAlertManager(final DataBroker dataBroker,
+                           final OpendaylightDirectStatisticsService odlDirectStatisticsService,
+                           final QosalertConfig defaultConfig,
+                           final OdlInterfaceRpcService odlInterfaceRpcService,
+                           final INeutronVpnManager neutronVpnManager) {
+
         LOG.info("{} created",  getClass().getSimpleName());
         this.dataBroker = dataBroker;
         this.odlDirectStatisticsService = odlDirectStatisticsService;
+        this.odlInterfaceRpcService = odlInterfaceRpcService;
+        this.neutronVpnManager =  neutronVpnManager;
         this.defaultConfig = defaultConfig;
         thread = null;
         LOG.info("QosAlert default config poll alertEnabled:{} threshold:{} pollInterval:{}",
@@ -167,6 +187,129 @@ public final class QosAlertManager implements Runnable {
         writeConfigDataStore();
     }
 
+    public static void addToQosAlertCache(Port port) {
+        LOG.trace("Adding port {} in cache", port.getUuid());
+
+        BigInteger dpnId = QosNeutronUtils.getDpnForInterface(odlInterfaceRpcService, port.getUuid().getValue());
+
+        if (dpnId.equals(BigInteger.ZERO)) {
+            LOG.debug("DPN ID for port {} not found", port.getUuid());
+            return;
+        }
+
+        String portNumber = QosNeutronUtils.getPortNumberForInterface(odlInterfaceRpcService,
+                                                                                 port.getUuid().getValue());
+
+        if (qosAlertDpnPortNumberMap.containsKey(dpnId)) {
+            LOG.trace("Adding port {}  port number {} in DPN {}", port.getUuid(), portNumber, dpnId);
+            qosAlertDpnPortNumberMap.get(dpnId).put(portNumber, new QosAlertPortData(port));
+        } else {
+            LOG.trace("Adding DPN ID {} with port {} port number {}", dpnId, port.getUuid(), portNumber);
+            ConcurrentHashMap<String, QosAlertPortData> portDataMap = new ConcurrentHashMap<>();
+            portDataMap.put(portNumber, new QosAlertPortData(port));
+            qosAlertDpnPortNumberMap.put(dpnId, portDataMap);
+        }
+    }
+
+    public static void addToQosAlertCache(Network network) {
+        LOG.trace("Adding network {} in cache", network.getUuid());
+
+        List<Uuid> subnetIds = QosNeutronUtils.getSubnetIdsFromNetworkId(dataBroker, network.getUuid());
+
+        if (subnetIds != null) {
+            for (Uuid subnetId : subnetIds) {
+                List<Uuid> portIds = QosNeutronUtils.getPortIdsFromSubnetId(dataBroker, subnetId);
+                if (portIds != null) {
+                    for (Uuid portId : portIds) {
+                        Port port = neutronVpnManager.getNeutronPort(portId);
+                        if (port != null) {
+                            if (!QosNeutronUtils.portHasQosPolicy(neutronVpnManager, port)) {
+                                LOG.trace("Adding network {} port {} in cache", network.getUuid(), port.getUuid());
+                                addToQosAlertCache(port);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    public static void removeFromQosAlertCache(Port port) {
+        LOG.trace("Removing port {} from cache", port.getUuid());
+
+        BigInteger dpnId = QosNeutronUtils.getDpnForInterface(odlInterfaceRpcService, port.getUuid().getValue());
+
+        if (dpnId.equals(BigInteger.ZERO)) {
+            LOG.debug("DPN ID for port {} not found", port.getUuid());
+            return;
+        }
+
+        String portNumber = QosNeutronUtils.getPortNumberForInterface(odlInterfaceRpcService,
+                                                                                  port.getUuid().getValue());
+
+        if (qosAlertDpnPortNumberMap.containsKey(dpnId)
+                                         && qosAlertDpnPortNumberMap.get(dpnId).containsKey(portNumber)) {
+            qosAlertDpnPortNumberMap.get(dpnId).remove(portNumber);
+            LOG.trace("Removed DPN {} port {} port number {} from cache", dpnId, port.getUuid(), portNumber);
+            if (qosAlertDpnPortNumberMap.get(dpnId).isEmpty()) {
+                LOG.trace("DPN {} empty. Removing from cache", dpnId);
+                qosAlertDpnPortNumberMap.remove(dpnId);
+            }
+        } else {
+            LOG.trace("DPN {} port {} port number {} not found in cache", dpnId, port.getUuid(), portNumber);
+        }
+
+    }
+
+    public static void removeFromQosAlertCache(NodeConnectorId nodeConnectorId) {
+        LOG.trace("Removing node connector {} from cache", nodeConnectorId.getValue());
+
+        long nodeId = MDSALUtil.getDpnIdFromPortName(nodeConnectorId);
+
+        if (nodeId == -1) {
+            LOG.debug("Node ID for node connector {} not found", nodeConnectorId.getValue());
+            return;
+        }
+
+        BigInteger dpnId = new BigInteger(String.valueOf(nodeId));
+
+        long portId = MDSALUtil.getOfPortNumberFromPortName(nodeConnectorId);
+
+        String portNumber = String.valueOf(portId);
+
+        if (qosAlertDpnPortNumberMap.containsKey(dpnId)
+                             && qosAlertDpnPortNumberMap.get(dpnId).containsKey(portNumber)) {
+            qosAlertDpnPortNumberMap.get(dpnId).remove(portNumber);
+            LOG.trace("Removed DPN {} port number {} from cache", dpnId, portNumber);
+        } else {
+            LOG.trace("DPN {} port number {} not found in cache", dpnId, portNumber);
+        }
+
+    }
+
+    public static void removeFromQosAlertCache(Network network) {
+        LOG.trace("Removing network {} from cache", network.getUuid());
+
+        List<Uuid> subnetIds = QosNeutronUtils.getSubnetIdsFromNetworkId(dataBroker, network.getUuid());
+
+        if (subnetIds != null) {
+            for (Uuid subnetId : subnetIds) {
+                List<Uuid> portIds = QosNeutronUtils.getPortIdsFromSubnetId(dataBroker, subnetId);
+                if (portIds != null) {
+                    for (Uuid portId : portIds) {
+                        Port port = neutronVpnManager.getNeutronPort(portId);
+                        if (port != null) {
+                            if (!QosNeutronUtils.portHasQosPolicy(neutronVpnManager, port)) {
+                                LOG.trace("Removing network {} port {} from cache", network.getUuid(), port.getUuid());
+                                removeFromQosAlertCache(port);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     private static <T extends DataObject> void asyncWrite(LogicalDatastoreType datastoreType,
                                                           InstanceIdentifier<T> path, T data, DataBroker broker,
                                                           FutureCallback<Void> callback) {
@@ -189,8 +332,15 @@ public final class QosAlertManager implements Runnable {
     }
 
     private void pollDirectStatisticsForAllNodes() {
-        LOG.debug("Polling direct statistics from all nodes");
-        // TODO: Add all polling logic here
+        LOG.trace("Polling direct statistics from nodes");
+        // TODO: Add all polling logic here. At this moment just print the port cache
+        for (BigInteger dpn : qosAlertDpnPortNumberMap.keySet()) {
+            LOG.trace("Polling DPN ID {}", dpn);
+            for (String portNumber : qosAlertDpnPortNumberMap.get(dpn).keySet()) {
+                LOG.trace("DPN ID {} PortNumber {} Port uuid {}",
+                        dpn, portNumber, qosAlertDpnPortNumberMap.get(dpn).get(portNumber).port.getUuid());
+            }
+        }
     }
 
 }

diff --git a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosAlertPortData.java b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosAlertPortData.java
new file mode 100644 (file)
index 0000000..01e02d3
--- /dev/null
+++ b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosAlertPortData.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2017 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,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.netvirt.qosservice;
+
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
+
+
+public class QosAlertPortData {
+    public  Port port;
+
+    public QosAlertPortData(Port port) {
+        this.port = port;
+    }
+}

diff --git a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosInterfaceStateChangeListener.java b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosInterfaceStateChangeListener.java
index f783c1d42cdccf895c2eb7d330adbcc43aac3d90..d8fde9eb8f81271cd7a05722a4bdaab43edbc336 100644 (file)
--- a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosInterfaceStateChangeListener.java
+++ b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosInterfaceStateChangeListener.java
@@ -25,6 +25,7 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.qos.ext.rev160613.QosNetworkExtension;
@@ -105,6 +106,9 @@ public class QosInterfaceStateChangeListener extends AsyncDataTreeChangeListener
                             }
                         }
                     }
+                    if (QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, port)) {
+                        QosAlertManager.addToQosAlertCache(port);
+                    }
                 });
             }
         } catch (Exception e) {
@@ -119,6 +123,12 @@ public class QosInterfaceStateChangeListener extends AsyncDataTreeChangeListener
 
     @Override
     protected void remove(InstanceIdentifier<Interface> identifier, Interface intrf) {
+        if (!Tunnel.class.equals(intrf.getType())) {
+            LOG.trace("Qos Service : Received interface {} PORT DOWN event ", intrf.getName());
+            String lowerLayerIf = intrf.getLowerLayerIf().get(0);
+            LOG.trace("lowerLayerIf {}", lowerLayerIf);
+            QosAlertManager.removeFromQosAlertCache(new NodeConnectorId(lowerLayerIf));
+        }
     }
 
     @Override

diff --git a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java
index 8796d578f6521bc784ba960a836fa31762199b8b..299f5873f689fc005265cdaa210d02049bb96e67 100644 (file)
--- a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java
+++ b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronNetworkChangeListener.java
@@ -67,6 +67,9 @@ public class QosNeutronNetworkChangeListener extends AsyncDataTreeChangeListener
 
     @Override
     protected void remove(InstanceIdentifier<Network> instanceIdentifier, Network network) {
+        if (QosNeutronUtils.hasBandwidthLimitRule(network)) {
+            QosAlertManager.removeFromQosAlertCache(network);
+        }
     }
 
     @Override
@@ -78,15 +81,32 @@ public class QosNeutronNetworkChangeListener extends AsyncDataTreeChangeListener
             QosNeutronUtils.addToQosNetworksCache(updateQos.getQosPolicyId(), update);
             QosNeutronUtils.handleNeutronNetworkQosUpdate(dataBroker, odlInterfaceRpcService,
                     neutronVpnManager, mdsalUtils, update, updateQos.getQosPolicyId());
+            if (QosNeutronUtils.hasBandwidthLimitRule(update)) {
+                QosAlertManager.addToQosAlertCache(update);
+            }
         } else if (originalQos != null && updateQos != null
                 && !originalQos.getQosPolicyId().equals(updateQos.getQosPolicyId())) {
+
             // qosservice policy update
+
             QosNeutronUtils.removeFromQosNetworksCache(originalQos.getQosPolicyId(), original);
             QosNeutronUtils.addToQosNetworksCache(updateQos.getQosPolicyId(), update);
             QosNeutronUtils.handleNeutronNetworkQosUpdate(dataBroker, odlInterfaceRpcService,
                     neutronVpnManager, mdsalUtils, 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(dataBroker, odlInterfaceRpcService,
                     neutronVpnManager, mdsalUtils, original, originalQos.getQosPolicyId());
             QosNeutronUtils.removeFromQosNetworksCache(originalQos.getQosPolicyId(), original);
@@ -100,6 +120,10 @@ public class QosNeutronNetworkChangeListener extends AsyncDataTreeChangeListener
             QosNeutronUtils.addToQosNetworksCache(networkQos.getQosPolicyId(), network);
             QosNeutronUtils.handleNeutronNetworkQosUpdate(dataBroker, odlInterfaceRpcService,
                     neutronVpnManager, mdsalUtils, network, networkQos.getQosPolicyId());
+            if (QosNeutronUtils.hasBandwidthLimitRule(network)) {
+                QosAlertManager.addToQosAlertCache(network);
+            }
+
         }
     }
 }

diff --git a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronPortChangeListener.java b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronPortChangeListener.java
index a78ced0188c8f5185b94105ef9a542a73c41d597..2156e677e5c06fbe9509f2dc84550cc3a90c0796 100644 (file)
--- a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronPortChangeListener.java
+++ b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronPortChangeListener.java
@@ -69,11 +69,16 @@ public class QosNeutronPortChangeListener extends AsyncDataTreeChangeListenerBas
 
     @Override
     protected void add(InstanceIdentifier<Port> instanceIdentifier, Port port) {
-       //do nothing
+        if (QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, port)) {
+            QosAlertManager.addToQosAlertCache(port);
+        }
     }
 
     @Override
     protected void remove(InstanceIdentifier<Port> instanceIdentifier, Port port) {
+        if (QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, port)) {
+            QosAlertManager.removeFromQosAlertCache(port);
+        }
         //Remove DSCP Flow when the port is removed
         //Qos Policy Deletion
         QosPortExtension removeQos = port.getAugmentation(QosPortExtension.class);
@@ -106,6 +111,7 @@ public class QosNeutronPortChangeListener extends AsyncDataTreeChangeListenerBas
                     update, updateQos.getQosPolicyId());
         } else if (originalQos != null && updateQos != null
                 && !originalQos.getQosPolicyId().equals(updateQos.getQosPolicyId())) {
+
             // qosservice policy update
             QosNeutronUtils.removeFromQosPortsCache(originalQos.getQosPolicyId(), original);
             QosNeutronUtils.addToQosPortsCache(updateQos.getQosPolicyId(), update);
@@ -117,6 +123,13 @@ public class QosNeutronPortChangeListener extends AsyncDataTreeChangeListenerBas
                     mdsalUtils, original, originalQos.getQosPolicyId());
             QosNeutronUtils.removeFromQosPortsCache(originalQos.getQosPolicyId(), original);
         }
+
+        if (QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, original)
+                                        && !QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, update)) {
+            QosAlertManager.removeFromQosAlertCache(original);
+        } else if (!QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager, original)
+                                          && QosNeutronUtils.hasBandwidthLimitRule(neutronVpnManager,update)) {
+            QosAlertManager.addToQosAlertCache(update);
+        }
     }
 }
-

diff --git a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronUtils.java b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronUtils.java
index 8950f4de6e30bf50e81cd31ff3bb6972348969e7..113fd86defef56ac6727d176a3186d6d7264eb6f 100644 (file)
--- a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronUtils.java
+++ b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosNeutronUtils.java
@@ -52,6 +52,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.met
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceInputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetDpidFromInterfaceOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.GetPortFromInterfaceOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rpcs.rev160406.OdlInterfaceRpcService;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceBindings;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.servicebinding.rev160406.ServiceModeIngress;
@@ -531,7 +534,7 @@ public class QosNeutronUtils {
         qosServiceConfiguredPorts.remove(port.getUuid());
     }
 
-    private static BigInteger getDpnForInterface(OdlInterfaceRpcService interfaceManagerRpcService, String ifName) {
+    public static BigInteger getDpnForInterface(OdlInterfaceRpcService interfaceManagerRpcService, String ifName) {
         BigInteger nodeId = BigInteger.ZERO;
         try {
             GetDpidFromInterfaceInput
@@ -717,6 +720,88 @@ public class QosNeutronUtils {
         return new StringBuffer().append(tableId).append(dpId).append(lportTag).toString();
     }
 
+    public static String getPortNumberForInterface(OdlInterfaceRpcService interfaceManagerRpcService, String ifName) {
+        GetPortFromInterfaceInput portNumberInput = new GetPortFromInterfaceInputBuilder().setIntfName(ifName).build();
+        Future<RpcResult<GetPortFromInterfaceOutput>> portNumberOutput =
+                interfaceManagerRpcService.getPortFromInterface(portNumberInput);
+        try {
+            RpcResult<GetPortFromInterfaceOutput> portResult = portNumberOutput.get();
+            if (portResult.isSuccessful()) {
+                return portResult.getResult().getPortno().toString();
+            }
+        } catch (NullPointerException | InterruptedException | ExecutionException e) {
+            LOG.warn("Exception when getting port for interface", e);
+        }
+        return null;
+    }
+
+    public static boolean portHasQosPolicy(INeutronVpnManager neutronVpnManager, Port port) {
+        Uuid qosUuid = null;
+        boolean isQosPolicy = false;
+
+        LOG.trace("checking qos policy for port: {}", port.getUuid());
+
+        if (port.getAugmentation(QosPortExtension.class) != null) {
+            qosUuid = port.getAugmentation(QosPortExtension.class).getQosPolicyId();
+        }
+        if (qosUuid != null) {
+            isQosPolicy = true;
+        }
+
+        LOG.trace("portHasQosPolicy for  port: {} return value {}", port.getUuid(), isQosPolicy);
+        return (isQosPolicy);
+    }
+
+    public static boolean hasBandwidthLimitRule(INeutronVpnManager neutronVpnManager, Port port) {
+        Uuid qosUuid = null;
+        boolean bwLimitRule = false;
+
+        LOG.trace("checking bandwidth limit rule for  port: {}", port.getUuid());
+
+        if (port.getAugmentation(QosPortExtension.class) != null) {
+            qosUuid = port.getAugmentation(QosPortExtension.class).getQosPolicyId();
+        } else {
+            Network network = neutronVpnManager.getNeutronNetwork(port.getNetworkId());
+
+            if (network.getAugmentation(QosNetworkExtension.class) != null) {
+                qosUuid = network.getAugmentation(QosNetworkExtension.class).getQosPolicyId();
+            }
+        }
+
+        if (qosUuid != null) {
+            QosPolicy qosPolicy = qosPolicyMap.get(qosUuid);
+            if (qosPolicy != null && qosPolicy.getBandwidthLimitRules() != null
+                    && !qosPolicy.getBandwidthLimitRules().isEmpty()) {
+                bwLimitRule = true;
+            }
+        }
+
+        LOG.trace("Bandwidth limit rule for  port: {} return value {}", port.getUuid(), bwLimitRule);
+        return (bwLimitRule);
+    }
+
+    public static boolean hasBandwidthLimitRule(Network network) {
+        boolean bwLimitRule = false;
+
+        LOG.trace("checking bandwidth limit rule for  network: {}", network.getUuid());
+
+        if (network.getAugmentation(QosNetworkExtension.class) != null) {
+            Uuid qosUuid = network.getAugmentation(QosNetworkExtension.class).getQosPolicyId();
+
+            if (qosUuid != null) {
+                QosPolicy qosPolicy = qosPolicyMap.get(qosUuid);
+                if (qosPolicy != null && qosPolicy.getBandwidthLimitRules() != null
+                        && !qosPolicy.getBandwidthLimitRules().isEmpty()) {
+                    bwLimitRule = true;
+                }
+            }
+        }
+
+        LOG.trace("Bandwidth limit rule for  network: {} return value {}", network.getUuid(), bwLimitRule);
+        return (bwLimitRule);
+    }
+
+
     // TODO Clean up the exception handling
     @SuppressWarnings("checkstyle:IllegalCatch")
     public static <T extends DataObject> Optional<T> read(DataBroker broker, LogicalDatastoreType datastoreType,

diff --git a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosPolicyChangeListener.java b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosPolicyChangeListener.java
index 3d5b0683c79fe8acc1dc952146892b29dc1ba648..bf2088dbcab7f83df5765aefaceb5de6451bce54 100644 (file)
--- a/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosPolicyChangeListener.java
+++ b/vpnservice/qosservice/impl/src/main/java/org/opendaylight/netvirt/qosservice/QosPolicyChangeListener.java
@@ -162,12 +162,14 @@ public class QosPolicyChangeListener extends AsyncDataTreeChangeListenerBase<Qos
             for (Network network : QosNeutronUtils.qosNetworksMap.get(qosUuid).values()) {
                 QosNeutronUtils.handleNeutronNetworkQosUpdate(dataBroker, odlInterfaceRpcService,
                         neutronVpnManager, mdsalUtils, network, qosUuid);
+                QosAlertManager.addToQosAlertCache(network);
             }
         }
 
         if (QosNeutronUtils.qosPortsMap.get(qosUuid) != null
                 && !QosNeutronUtils.qosPortsMap.get(qosUuid).isEmpty()) {
             for (Port port : QosNeutronUtils.qosPortsMap.get(qosUuid).values()) {
+                QosAlertManager.addToQosAlertCache(port);
                 final DataStoreJobCoordinator portDataStoreCoordinator =
                         DataStoreJobCoordinator.getInstance();
                 portDataStoreCoordinator.enqueueJob("QosPort-" + port.getUuid().getValue(), () -> {
@@ -228,6 +230,7 @@ public class QosPolicyChangeListener extends AsyncDataTreeChangeListenerBase<Qos
         if (QosNeutronUtils.qosNetworksMap.get(qosUuid) != null
                 && !QosNeutronUtils.qosNetworksMap.get(qosUuid).isEmpty()) {
             for (Network network : QosNeutronUtils.qosNetworksMap.get(qosUuid).values()) {
+                QosAlertManager.removeFromQosAlertCache(network);
                 QosNeutronUtils.handleNeutronNetworkQosBwRuleRemove(dataBroker, odlInterfaceRpcService,
                         neutronVpnManager, network, zeroBwLimitRule);
             }
@@ -236,6 +239,7 @@ public class QosPolicyChangeListener extends AsyncDataTreeChangeListenerBase<Qos
         if (QosNeutronUtils.qosPortsMap.get(qosUuid) != null
                 && !QosNeutronUtils.qosPortsMap.get(qosUuid).isEmpty()) {
             for (Port port : QosNeutronUtils.qosPortsMap.get(qosUuid).values()) {
+                QosAlertManager.removeFromQosAlertCache(port);
                 final DataStoreJobCoordinator portDataStoreCoordinator =
                         DataStoreJobCoordinator.getInstance();
                 portDataStoreCoordinator.enqueueJob("QosPort-" + port.getUuid().getValue(), () -> {