Migrating FCAPSApplication PM Counters to Infrautils Counters

Change-Id: I2a4edeeb9deb72de15b8e4b75adf225843c4ddfb
Signed-off-by: Ankit <ank123it@gmail.com>

diff --git a/fcapsapplication/fcapsapplication-impl/pom.xml b/fcapsapplication/fcapsapplication-impl/pom.xml
index 9cb5df51a7b0d688ec6ea6c98aec921901070206..657f25f169d87b5da866c19673997aca1955ba10 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/pom.xml
+++ b/fcapsapplication/fcapsapplication-impl/pom.xml
@@ -29,6 +29,11 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
       <groupId>org.opendaylight.controller</groupId>
       <artifactId>sal-binding-broker-impl</artifactId>
     </dependency>
+    <dependency>
+      <groupId>org.opendaylight.infrautils</groupId>
+      <artifactId>metrics-api</artifactId>
+      <version>${genius.infrautils.version}</version>
+    </dependency>
     <dependency>
       <groupId>org.opendaylight.controller</groupId>
       <artifactId>sal-binding-api</artifactId>

diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java
index 7c056c32a9ce7a4916632d7e280730d1773be98f..32e7ad604783aebaf12b478e84b745ff3905fb00 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java
+++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/NodeEventListener.java
@@ -19,6 +19,7 @@ import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeLis
 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
 import org.opendaylight.genius.fcapsapp.alarm.AlarmAgent;
+import org.opendaylight.genius.fcapsapp.performancecounter.FlowNodeConnectorInventoryTranslatorImpl;
 import org.opendaylight.genius.fcapsapp.performancecounter.NodeUpdateCounter;
 import org.opendaylight.genius.fcapsapp.performancecounter.PacketInCounterHandler;
 import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
@@ -38,17 +39,20 @@ public class NodeEventListener<D extends DataObject> implements ClusteredDataTre
     public final PacketInCounterHandler packetInCounterHandler;
     private final EntityOwnershipUtils entityOwnershipUtils;
     private final EntityOwnershipService entityOwnershipService;
+    private final FlowNodeConnectorInventoryTranslatorImpl nodeConnectorInventoryTranslator;
 
     @Inject
     public NodeEventListener(final AlarmAgent alarmAgent, final NodeUpdateCounter nodeUpdateCounter,
                              final PacketInCounterHandler packetInCounterHandler,
                              final EntityOwnershipUtils entityOwnershipUtils,
-                             final EntityOwnershipService entityOwnershipService) {
+                             final EntityOwnershipService entityOwnershipService,
+                             final FlowNodeConnectorInventoryTranslatorImpl nodeConnectorInventoryTranslator) {
         this.alarmAgent = alarmAgent;
         this.nodeUpdateCounter = nodeUpdateCounter;
         this.packetInCounterHandler = packetInCounterHandler;
         this.entityOwnershipUtils = entityOwnershipUtils;
         this.entityOwnershipService = entityOwnershipService;
+        this.nodeConnectorInventoryTranslator = nodeConnectorInventoryTranslator;
     }
 
     @PostConstruct
@@ -84,6 +88,7 @@ public class NodeEventListener<D extends DataObject> implements ClusteredDataTre
                     if (nodeUpdateCounter.isDpnConnectedLocal(nodeId)) {
                         alarmAgent.raiseControlPathAlarm(nodeId, hostName);
                         nodeUpdateCounter.nodeRemovedNotification(nodeId, hostName);
+                        nodeConnectorInventoryTranslator.nodeRemovedNotification(nodeId);
                     }
                     packetInCounterHandler.nodeRemovedNotification(nodeId);
                     break;

diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java
index 58931c5f01417998095652d6b1de6aa219f0c607..23b0583809d66e5859206d7de5cc91ace4f629b2 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java
+++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/FlowNodeConnectorInventoryTranslatorImpl.java
@@ -12,8 +12,6 @@ import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Multimap;
 import com.google.common.collect.Multimaps;
-import java.util.Collection;
-import java.util.HashMap;
 import javax.annotation.PreDestroy;
 import javax.inject.Inject;
 import javax.inject.Singleton;
@@ -23,6 +21,10 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
 import org.opendaylight.genius.fcapsapp.FcapsConstants;
 import org.opendaylight.genius.fcapsapp.portinfo.PortNameMapping;
 import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
+import org.opendaylight.infrautils.metrics.Counter;
+import org.opendaylight.infrautils.metrics.Labeled;
+import org.opendaylight.infrautils.metrics.MetricDescriptor;
+import org.opendaylight.infrautils.metrics.MetricProvider;
 import org.opendaylight.openflowplugin.common.wait.SimpleTaskRetryLooper;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
@@ -45,8 +47,8 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
     private ListenerRegistration<FlowNodeConnectorInventoryTranslatorImpl> dataTreeChangeListenerRegistration;
 
     private static final String SEPARATOR = ":";
-    private final PMAgent agent;
-
+    private final MetricProvider metricProvider;
+    private final Labeled<Labeled<Labeled<Counter>>> packetInCounter;
     private static final InstanceIdentifier<FlowCapableNodeConnector>
             II_TO_FLOW_CAPABLE_NODE_CONNECTOR = InstanceIdentifier
             .builder(Nodes.class).child(Node.class).child(NodeConnector.class)
@@ -55,15 +57,18 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
     private static Multimap<Long, String> dpnToPortMultiMap = Multimaps
             .synchronizedListMultimap(ArrayListMultimap.<Long, String>create());
 
-    private static HashMap<String, String> nodeConnectorCountermap = new HashMap<>();
 
     @Inject
     @SuppressWarnings("checkstyle:IllegalCatch")
-    public FlowNodeConnectorInventoryTranslatorImpl(final DataBroker dataBroker, final PMAgent agent,
-                                                    final EntityOwnershipUtils entityOwnershipUtils) {
+    public FlowNodeConnectorInventoryTranslatorImpl(final DataBroker dataBroker,
+                                                    final EntityOwnershipUtils entityOwnershipUtils,
+                                                    MetricProvider metricProvider) {
         this.dataBroker = Preconditions.checkNotNull(dataBroker, "DataBroker can not be null!");
         this.entityOwnershipUtils = entityOwnershipUtils;
-        this.agent = agent;
+        this.metricProvider = metricProvider;
+        packetInCounter =  metricProvider.newCounter(MetricDescriptor.builder().anchor(this)
+                .project("genius").module("fcapsapplication")
+                .id("entitycounter").build(), "entitytype", "switchid","name");
         final DataTreeIdentifier<FlowCapableNodeConnector> treeId = new DataTreeIdentifier<>(
                 LogicalDatastoreType.OPERATIONAL, getWildCardPath());
         try {
@@ -94,7 +99,8 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
 
     @Override
     public void remove(InstanceIdentifier<FlowCapableNodeConnector> identifier, FlowCapableNodeConnector del,
-            InstanceIdentifier<FlowCapableNodeConnector> nodeConnIdent) {
+                       InstanceIdentifier<FlowCapableNodeConnector> nodeConnIdent) {
+        Counter counter;
         if (compareInstanceIdentifierTail(identifier, II_TO_FLOW_CAPABLE_NODE_CONNECTOR)) {
             String nodeConnectorIdentifier = getNodeConnectorId(
                     String.valueOf(nodeConnIdent.firstKeyOf(NodeConnector.class).getId()));
@@ -102,7 +108,8 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
             if (dpnToPortMultiMap.containsKey(dataPathId)) {
                 LOG.debug("Node Connector {} removed", nodeConnectorIdentifier);
                 dpnToPortMultiMap.remove(dataPathId, nodeConnectorIdentifier);
-                sendNodeConnectorUpdation(dataPathId);
+                counter = packetInCounter.label("OFSwitch").label(String.valueOf(dataPathId)).label("portsperswitch");
+                counter.decrement();
                 PortNameMapping.updatePortMap("openflow:" + dataPathId + ":" + del.getName(), nodeConnectorIdentifier,
                         "DELETE");
             }
@@ -118,6 +125,7 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
     @Override
     public void add(InstanceIdentifier<FlowCapableNodeConnector> identifier, FlowCapableNodeConnector add,
             InstanceIdentifier<FlowCapableNodeConnector> nodeConnIdent) {
+        Counter counter;
         if (compareInstanceIdentifierTail(identifier, II_TO_FLOW_CAPABLE_NODE_CONNECTOR)) {
 
             String nodeConnectorIdentifier = getNodeConnectorId(
@@ -127,7 +135,9 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
                 if (!dpnToPortMultiMap.containsEntry(dataPathId, nodeConnectorIdentifier)) {
                     LOG.debug("Node Connector {} added", nodeConnectorIdentifier);
                     dpnToPortMultiMap.put(dataPathId, nodeConnectorIdentifier);
-                    sendNodeConnectorUpdation(dataPathId);
+                    counter = packetInCounter.label("OFSwitch")
+                            .label(String.valueOf(dataPathId)).label("portsperswitch");
+                    counter.increment();
                     PortNameMapping.updatePortMap("openflow:" + dataPathId + ":" + add.getName(),
                             nodeConnectorIdentifier, "ADD");
                 } else {
@@ -158,17 +168,10 @@ public class FlowNodeConnectorInventoryTranslatorImpl extends NodeConnectorEvent
         return Long.parseLong(dpId);
     }
 
-    private void sendNodeConnectorUpdation(Long dpnId) {
-        Collection<String> portname = dpnToPortMultiMap.get(dpnId);
-        String nodeListPortsCountStr = "dpnId_" + dpnId + "_NumberOfOFPorts";
-        String counterkey = "NumberOfOFPorts:" + nodeListPortsCountStr;
-
-        if (!portname.isEmpty()) {
-            nodeConnectorCountermap.put(counterkey, "" + portname.size());
-        } else {
-            nodeConnectorCountermap.remove(counterkey);
-        }
-        LOG.debug("NumberOfOFPorts: {} portlistsize {}", nodeListPortsCountStr, portname.size());
-        agent.connectToPMAgentForNOOfPorts(nodeConnectorCountermap);
+    public void nodeRemovedNotification(String node) {
+        Counter counter;
+        String[] switchId = node.split(":");
+        counter = packetInCounter.label("OFSwitch").label(String.valueOf(switchId[1])).label("portsperswitch");
+        counter.close();
     }
 }

diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/NodeUpdateCounter.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/NodeUpdateCounter.java
index 31172a3e331d9b9cc6af74a1a7226c6cd2ea7a59..91ad23d61e0e5891a89086fe9044d7bcea55f79a 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/NodeUpdateCounter.java
+++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/NodeUpdateCounter.java
@@ -7,11 +7,13 @@
  */
 package org.opendaylight.genius.fcapsapp.performancecounter;
 
-import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Map;
 import javax.inject.Inject;
 import javax.inject.Singleton;
+import org.opendaylight.infrautils.metrics.Counter;
+import org.opendaylight.infrautils.metrics.Labeled;
+import org.opendaylight.infrautils.metrics.MetricDescriptor;
+import org.opendaylight.infrautils.metrics.MetricProvider;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -22,34 +24,30 @@ public class NodeUpdateCounter {
     private String nodeListEFSCountStr;
     private static HashSet<String> dpnList = new HashSet<>();
     public final PMAgent agent;
-    private final Map<String, String> countersMap = new HashMap<>();
+    private final MetricProvider metricProvider;
+    private final Labeled<Labeled<Labeled<Counter>>> packetInCounter;
 
     @Inject
-    public NodeUpdateCounter(final PMAgent agent) {
+    public NodeUpdateCounter(final PMAgent agent, final MetricProvider metricProvider) {
         this.agent = agent;
+        this.metricProvider = metricProvider;
+        packetInCounter =  metricProvider.newCounter(MetricDescriptor.builder().anchor(this)
+                .project("genius").module("fcapsapplication")
+                .id("entitycounter").build(), "entitytype", "hostid","name");
     }
 
     public void nodeAddedNotification(String node, String hostName) {
+        Counter counter;
         dpnList.add(node);
-        sendNodeUpdation(dpnList.size(), hostName);
+        counter = packetInCounter.label("OFSwitch").label(hostName).label("switchespernode");
+        counter.increment();
     }
 
     public void nodeRemovedNotification(String node, String hostName) {
+        Counter counter;
         dpnList.remove(node);
-        sendNodeUpdation(dpnList.size(), hostName);
-    }
-
-    private void sendNodeUpdation(Integer count, String hostName) {
-
-        if (hostName != null) {
-            nodeListEFSCountStr = "Node_" + hostName + "_NumberOfEFS";
-            LOG.debug("NumberOfEFS: {} dpnList.size {}", nodeListEFSCountStr, count);
-
-            countersMap.put("NumberOfEFS:" + nodeListEFSCountStr, "" + count);
-            agent.connectToPMAgent(countersMap);
-        } else {
-            LOG.error("Hostname is null upon NumberOfEFS counter");
-        }
+        counter = packetInCounter.label("OFSwitch").label(hostName).label("switchespernode");
+        counter.close();
     }
 
     public boolean isDpnConnectedLocal(String node) {

diff --git a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/PacketInCounterHandler.java b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/PacketInCounterHandler.java
index 0f6af66c539493a027223a44900c311e70dc35ee..ff9a5075ed064fe5d77af57ef63c6711a71df930 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/PacketInCounterHandler.java
+++ b/fcapsapplication/fcapsapplication-impl/src/main/java/org/opendaylight/genius/fcapsapp/performancecounter/PacketInCounterHandler.java
@@ -7,14 +7,13 @@
  */
 package org.opendaylight.genius.fcapsapp.performancecounter;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.atomic.AtomicLong;
 import javax.annotation.Nonnull;
 import javax.inject.Inject;
 import javax.inject.Singleton;
+import org.opendaylight.infrautils.metrics.Counter;
+import org.opendaylight.infrautils.metrics.Labeled;
+import org.opendaylight.infrautils.metrics.MetricDescriptor;
+import org.opendaylight.infrautils.metrics.MetricProvider;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingListener;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketReceived;
 import org.slf4j.Logger;
@@ -23,18 +22,23 @@ import org.slf4j.LoggerFactory;
 @Singleton
 public class PacketInCounterHandler implements PacketProcessingListener {
     private static final Logger LOG = LoggerFactory.getLogger(PacketInCounterHandler.class);
-    private static final Long FIRST_VALUE = 0L;
 
     private final PMAgent agent;
-    private final ConcurrentMap<String, AtomicLong> ingressPacketMap = new ConcurrentHashMap<>();
+    private final MetricProvider metricProvider;
+    private final Labeled<Labeled<Labeled<Counter>>> packetInCounter;
 
     @Inject
-    public PacketInCounterHandler(final PMAgent agent) {
+    public PacketInCounterHandler(final PMAgent agent, MetricProvider metricProvider) {
         this.agent = agent;
+        this.metricProvider = metricProvider;
+        packetInCounter =  metricProvider.newCounter(MetricDescriptor.builder().anchor(this)
+                .project("genius").module("fcapsapplication").id("entitycounter")
+                .build(), "entitytype", "switchid","name");
     }
 
     @Override
     public void onPacketReceived(PacketReceived notification) {
+        Counter counter;
         LOG.debug("Ingress packet notification received");
         if (notification.getIngress() == null) {
             if (LOG.isWarnEnabled()) {
@@ -43,20 +47,14 @@ public class PacketInCounterHandler implements PacketProcessingListener {
             return;
         }
         String dpnId = getDpnId(notification.getIngress().getValue().toString());
-        ingressPacketMap.computeIfAbsent(dpnId, (counter -> new AtomicLong(FIRST_VALUE))).incrementAndGet();
-        connectToPMAgent();
-    }
-
-    private void connectToPMAgent() {
-        Map<String, String> packetInMap = new HashMap<>();
-        ingressPacketMap.forEach((dpnId, count) -> packetInMap
-                .put("InjectedOFMessagesSent:" + "dpnId_" + dpnId + "_InjectedOFMessagesSent", String.valueOf(count)));
-        agent.sendPacketInCounterUpdate(packetInMap);
+        counter = packetInCounter.label("OFSwitch").label(dpnId).label("packetin");
+        counter.increment();
     }
 
     /*
      * Method to extract DpnId
      */
+
     @Nonnull
     private String getDpnId(@Nonnull String id) {
         String[] nodeNo = id.split(":");
@@ -65,14 +63,12 @@ public class PacketInCounterHandler implements PacketProcessingListener {
     }
 
     public void nodeRemovedNotification(String dpnId) {
+        Counter counter;
         if (dpnId != null) {
             dpnId = dpnId.split(":")[1];
             LOG.debug("Dpnvalue Id {}", dpnId);
-            if (ingressPacketMap.containsKey(dpnId)) {
-                ingressPacketMap.remove(dpnId);
-                connectToPMAgent();
-                LOG.debug("Node {} Removed for PacketIn counter", dpnId);
-            }
+            counter = packetInCounter.label("OFSwitch").label(dpnId).label("packetin");
+            counter.close();
         } else {
             LOG.error("DpnId is null upon nodeRemovedNotification");
         }

diff --git a/fcapsapplication/fcapsapplication-impl/src/main/resources/org/opendaylight/blueprint/fcaps-app.xml b/fcapsapplication/fcapsapplication-impl/src/main/resources/org/opendaylight/blueprint/fcaps-app.xml
index bdcb142775a0658b53b6715f4efc36a11ef4c488..84d26ac1c310fc98931b3a45d0c8aec167f52f96 100644 (file)
--- a/fcapsapplication/fcapsapplication-impl/src/main/resources/org/opendaylight/blueprint/fcaps-app.xml
+++ b/fcapsapplication/fcapsapplication-impl/src/main/resources/org/opendaylight/blueprint/fcaps-app.xml
@@ -19,6 +19,9 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
     <reference id="notificationService"
                interface="org.opendaylight.controller.md.sal.binding.api.NotificationService"/>
 
+    <reference id="metricProvider"
+               interface="org.opendaylight.infrautils.metrics.MetricProvider"/>
+
     <bean id="entityOwnershipUtils" class="org.opendaylight.genius.utils.clustering.EntityOwnershipUtils">
         <argument ref="entityOwnershipService"/>
     </bean>

diff --git a/features/odl-genius-fcaps-application/pom.xml b/features/odl-genius-fcaps-application/pom.xml
index 94e1dc4c3f74eb817bc4e9b83b5b0ac2289ccbd4..c3a1b2896560fb8eba596ac160b118aedb0b0a36 100644 (file)
--- a/features/odl-genius-fcaps-application/pom.xml
+++ b/features/odl-genius-fcaps-application/pom.xml
@@ -46,6 +46,13 @@
       <type>xml</type>
       <classifier>features</classifier>
     </dependency>
+    <dependency>
+      <groupId>org.opendaylight.infrautils</groupId>
+      <artifactId>odl-infrautils-metrics</artifactId>
+      <version>1.3.0-SNAPSHOT</version>
+      <type>xml</type>
+      <classifier>features</classifier>
+    </dependency>
 
     <!-- External libraries to wrap -->
     <dependency>