HwVTEP support for interfacemanager

[vpnservice.git] / interfacemgr / interfacemgr-impl / src / main / java / org / opendaylight / vpnservice / interfacemgr / pmcounters / PMAgentForNodeConnectorCounters.java

diff --git a/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/pmcounters/PMAgentForNodeConnectorCounters.java b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/pmcounters/PMAgentForNodeConnectorCounters.java
new file mode 100644 (file)
index 0000000..acea10e
--- /dev/null
+++ b/interfacemgr/interfacemgr-impl/src/main/java/org/opendaylight/vpnservice/interfacemgr/pmcounters/PMAgentForNodeConnectorCounters.java
@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2016 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.vpnservice.interfacemgr.pmcounters;
+
+import java.lang.management.ManagementFactory;
+import java.util.Map;
+
+import javax.management.InstanceNotFoundException;
+import javax.management.MBeanException;
+import javax.management.MBeanServer;
+import javax.management.MalformedObjectNameException;
+import javax.management.ObjectName;
+import javax.management.ReflectionException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PMAgentForNodeConnectorCounters {
+
+    private static Logger logger = LoggerFactory.getLogger(PMAgentForNodeConnectorCounters.class);
+    private MBeanServer mbServer = null;
+    private ObjectName mbeanForOFPortDuration = null;
+    private ObjectName mbeanForOFPortReceiveDrop = null;
+    private ObjectName mbeanForOFPortReceiveError = null;
+    private ObjectName mbeanForOFPortPacketSent = null;
+    private ObjectName mbeanForOFPortPacketReceive = null;
+    private ObjectName mbeanForOFPortBytesSent = null;
+    private ObjectName mbeanForOFPortBytesReceive = null;
+    private ObjectName mbeanForEntriesPerOFTable = null;
+    private static final String BEANNAMEFOROFPORTDURATION = "SDNC.PM:type=CounterForOFPortDuration";
+    private static final String BEANNAMEFOROFPORTREVEIVEDROP = "SDNC.PM:type=CounterForOFPortReceiveDrop";
+    private static final String BEANNAMEFOROFPORTREVEIVEERROR = "SDNC.PM:type=CounterForOFPortReceiveError";
+    private static final String BEANNAMEFOROFPORTPACKETSENT = "SDNC.PM:type=CounterForOFPortPacketSent";
+    private static final String BEANNAMEFOROFPORTPACKETRECEIVE = "SDNC.PM:type=CounterForOFPortPacketReceive";
+    private static final String BEANNAMEFOROFPORTBYTESSENT = "SDNC.PM:type=CounterForOFPortBytesSent";
+    private static final String BEANNAMEFOROFPORTBYTESRECEIVE = "SDNC.PM:type=CounterForOFPortBytesReceive";
+    private static final String BEANNAMEFORENTRIESPEROFTABLE = "SDNC.PM:type=CounterForEntriesPerOFTable";
+    private static CounterForOFPortDuration counterForOFPortDurationBean = new CounterForOFPortDuration();
+    private static CounterForOFPortReceiveDrop counterForOFPortReceiveDropBean = new CounterForOFPortReceiveDrop();
+    private static CounterForOFPortReceiveError counterForOFPortReceiveErrorBean = new CounterForOFPortReceiveError();
+    private static CounterForOFPortPacketSent counterForOFPortPacketSent = new CounterForOFPortPacketSent();
+    private static CounterForOFPortPacketReceive counterForOFPortPacketReceive = new CounterForOFPortPacketReceive();
+    private static CounterForOFPortBytesSent counterForOFPortBytesSent = new CounterForOFPortBytesSent();
+    private static CounterForOFPortBytesReceive counterForOFPortBytesReceive = new CounterForOFPortBytesReceive();
+    private static CounterForEntriesPerOFTable counterForEntriesPerOFTable = new CounterForEntriesPerOFTable();
+
+    public PMAgentForNodeConnectorCounters() {
+        // Get the platform MBeanServer
+        mbServer = ManagementFactory.getPlatformMBeanServer();
+        try {
+            mbeanForOFPortDuration = new ObjectName(BEANNAMEFOROFPORTDURATION);
+            mbeanForOFPortReceiveDrop = new ObjectName(BEANNAMEFOROFPORTREVEIVEDROP);
+            mbeanForOFPortReceiveError = new ObjectName(BEANNAMEFOROFPORTREVEIVEERROR);
+            mbeanForOFPortPacketSent = new ObjectName(BEANNAMEFOROFPORTPACKETSENT);
+            mbeanForOFPortPacketReceive = new ObjectName(BEANNAMEFOROFPORTPACKETRECEIVE);
+            mbeanForOFPortBytesSent = new ObjectName(BEANNAMEFOROFPORTBYTESSENT);
+            mbeanForOFPortBytesReceive = new ObjectName(BEANNAMEFOROFPORTBYTESRECEIVE);
+            mbeanForEntriesPerOFTable = new ObjectName(BEANNAMEFORENTRIESPEROFTABLE);
+        } catch (MalformedObjectNameException e) {
+            logger.error("ObjectName instance creation failed with exception {}", e);
+
+        }
+    }
+
+    public void registerMbean() {
+        try {
+            // Uniquely identify the MBeans and register them with the platform MBeanServer
+            if(!mbServer.isRegistered(mbeanForOFPortDuration)) {
+                mbServer.registerMBean(counterForOFPortDurationBean, mbeanForOFPortDuration);
+                logger.info("Registered Mbean {} successfully", mbeanForOFPortDuration);
+            }
+            if(!mbServer.isRegistered(mbeanForOFPortReceiveDrop)) {
+                mbServer.registerMBean(counterForOFPortReceiveDropBean, mbeanForOFPortReceiveDrop);
+                logger.info("Registered Mbean {} successfully", mbeanForOFPortReceiveDrop);
+            }
+            if(!mbServer.isRegistered(mbeanForOFPortReceiveError)) {
+                mbServer.registerMBean(counterForOFPortReceiveErrorBean, mbeanForOFPortReceiveError);
+                logger.info("Registered Mbean {} successfully", mbeanForOFPortReceiveError);
+            }
+            if(!mbServer.isRegistered(mbeanForOFPortPacketSent)) {
+                mbServer.registerMBean(counterForOFPortPacketSent, mbeanForOFPortPacketSent);
+                logger.info("Registered Mbean {} successfully", mbeanForOFPortPacketSent);
+            }
+            if(!mbServer.isRegistered(mbeanForOFPortPacketReceive)) {
+                mbServer.registerMBean(counterForOFPortPacketReceive, mbeanForOFPortPacketReceive);
+                logger.info("Registered Mbean {} successfully", mbeanForOFPortPacketReceive);
+            }
+            if(!mbServer.isRegistered(mbeanForOFPortBytesSent)) {
+                mbServer.registerMBean(counterForOFPortBytesSent, mbeanForOFPortBytesSent);
+                logger.info("Registered Mbean {} successfully", mbeanForOFPortBytesSent);
+            }
+            if(!mbServer.isRegistered(mbeanForOFPortBytesReceive)) {
+                mbServer.registerMBean(counterForOFPortBytesReceive, mbeanForOFPortBytesReceive);
+                logger.info("Registered Mbean {} successfully", mbeanForOFPortBytesReceive);
+            }
+            if(!mbServer.isRegistered(mbeanForEntriesPerOFTable)) {
+                mbServer.registerMBean(counterForEntriesPerOFTable, mbeanForEntriesPerOFTable);
+                logger.info("Registered Mbean {} successfully", mbeanForEntriesPerOFTable);
+            }
+        } catch(Exception e) {
+            logger.error("Registeration failed with exception {}", e);
+        }
+    }
+
+
+    public synchronized void connectToPMAgent(Map<String, String> ofPortDurationCounter, Map<String, String> ofPortReceiveDropCounter, 
+            Map<String, String> ofPortReceiveErrorCounter, Map<String, String> ofPortPacketSent, Map<String, String> ofPortPacketReceive, 
+            Map<String, String> ofPortBytesSent, Map<String, String> ofPortBytesReceive) {
+        try {
+                mbServer.invoke(mbeanForOFPortDuration, "invokePMManagedObjects", new Object[]{ofPortDurationCounter}, new String[]{Map.class.getName()});
+                mbServer.invoke(mbeanForOFPortReceiveDrop, "invokePMManagedObjects", new Object[]{ofPortReceiveDropCounter}, new String[]{Map.class.getName()});
+                mbServer.invoke(mbeanForOFPortReceiveError, "invokePMManagedObjects", new Object[]{ofPortReceiveErrorCounter}, new String[]{Map.class.getName()});
+                mbServer.invoke(mbeanForOFPortPacketSent, "invokePMManagedObjects", new Object[]{ofPortPacketSent}, new String[]{Map.class.getName()});
+                mbServer.invoke(mbeanForOFPortPacketReceive, "invokePMManagedObjects", new Object[]{ofPortPacketReceive}, new String[]{Map.class.getName()});
+                mbServer.invoke(mbeanForOFPortBytesSent, "invokePMManagedObjects", new Object[]{ofPortBytesSent}, new String[]{Map.class.getName()});
+                mbServer.invoke(mbeanForOFPortBytesReceive, "invokePMManagedObjects", new Object[]{ofPortBytesReceive}, new String[]{Map.class.getName()});
+        } catch (InstanceNotFoundException e ) {
+            logger.error(" InstanceNotFoundException ", e);
+        } catch (MBeanException e) {
+            logger.error(" MBeanException ", e);
+        } catch (ReflectionException e) {
+            logger.error(" ReflectionException ", e);
+        }
+    }
+
+    public synchronized void connectToPMAgentAndInvokeEntriesPerOFTable(Map<String, String> entriesPerOFTable) {
+        try {
+                mbServer.invoke(mbeanForEntriesPerOFTable, "invokePMManagedObjects", new Object[]{entriesPerOFTable}, new String[]{Map.class.getName()});
+        } catch (InstanceNotFoundException e ) {
+            logger.error(" InstanceNotFoundException ", e);
+        } catch (MBeanException e) {
+            logger.error(" MBeanException ", e);
+        } catch (ReflectionException e) {
+            logger.error(" ReflectionException ", e);
+        }
+    }
+}