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

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.vpnservice.interfacemgr.pmcounters;
   9
  10 import java.lang.management.ManagementFactory;
  11 import java.util.Map;
  12
  13 import javax.management.InstanceNotFoundException;
  14 import javax.management.MBeanException;
  15 import javax.management.MBeanServer;
  16 import javax.management.MalformedObjectNameException;
  17 import javax.management.ObjectName;
  18 import javax.management.ReflectionException;
  19
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 public class PMAgentForNodeConnectorCounters {
  24
  25     private static Logger logger = LoggerFactory.getLogger(PMAgentForNodeConnectorCounters.class);
  26     private MBeanServer mbServer = null;
  27     private ObjectName mbeanForOFPortDuration = null;
  28     private ObjectName mbeanForOFPortReceiveDrop = null;
  29     private ObjectName mbeanForOFPortReceiveError = null;
  30     private ObjectName mbeanForOFPortPacketSent = null;
  31     private ObjectName mbeanForOFPortPacketReceive = null;
  32     private ObjectName mbeanForOFPortBytesSent = null;
  33     private ObjectName mbeanForOFPortBytesReceive = null;
  34     private ObjectName mbeanForEntriesPerOFTable = null;
  35     private static final String BEANNAMEFOROFPORTDURATION = "SDNC.PM:type=CounterForOFPortDuration";
  36     private static final String BEANNAMEFOROFPORTREVEIVEDROP = "SDNC.PM:type=CounterForOFPortReceiveDrop";
  37     private static final String BEANNAMEFOROFPORTREVEIVEERROR = "SDNC.PM:type=CounterForOFPortReceiveError";
  38     private static final String BEANNAMEFOROFPORTPACKETSENT = "SDNC.PM:type=CounterForOFPortPacketSent";
  39     private static final String BEANNAMEFOROFPORTPACKETRECEIVE = "SDNC.PM:type=CounterForOFPortPacketReceive";
  40     private static final String BEANNAMEFOROFPORTBYTESSENT = "SDNC.PM:type=CounterForOFPortBytesSent";
  41     private static final String BEANNAMEFOROFPORTBYTESRECEIVE = "SDNC.PM:type=CounterForOFPortBytesReceive";
  42     private static final String BEANNAMEFORENTRIESPEROFTABLE = "SDNC.PM:type=CounterForEntriesPerOFTable";
  43     private static CounterForOFPortDuration counterForOFPortDurationBean = new CounterForOFPortDuration();
  44     private static CounterForOFPortReceiveDrop counterForOFPortReceiveDropBean = new CounterForOFPortReceiveDrop();
  45     private static CounterForOFPortReceiveError counterForOFPortReceiveErrorBean = new CounterForOFPortReceiveError();
  46     private static CounterForOFPortPacketSent counterForOFPortPacketSent = new CounterForOFPortPacketSent();
  47     private static CounterForOFPortPacketReceive counterForOFPortPacketReceive = new CounterForOFPortPacketReceive();
  48     private static CounterForOFPortBytesSent counterForOFPortBytesSent = new CounterForOFPortBytesSent();
  49     private static CounterForOFPortBytesReceive counterForOFPortBytesReceive = new CounterForOFPortBytesReceive();
  50     private static CounterForEntriesPerOFTable counterForEntriesPerOFTable = new CounterForEntriesPerOFTable();
  51
  52     public PMAgentForNodeConnectorCounters() {
  53         // Get the platform MBeanServer
  54         mbServer = ManagementFactory.getPlatformMBeanServer();
  55         try {
  56             mbeanForOFPortDuration = new ObjectName(BEANNAMEFOROFPORTDURATION);
  57             mbeanForOFPortReceiveDrop = new ObjectName(BEANNAMEFOROFPORTREVEIVEDROP);
  58             mbeanForOFPortReceiveError = new ObjectName(BEANNAMEFOROFPORTREVEIVEERROR);
  59             mbeanForOFPortPacketSent = new ObjectName(BEANNAMEFOROFPORTPACKETSENT);
  60             mbeanForOFPortPacketReceive = new ObjectName(BEANNAMEFOROFPORTPACKETRECEIVE);
  61             mbeanForOFPortBytesSent = new ObjectName(BEANNAMEFOROFPORTBYTESSENT);
  62             mbeanForOFPortBytesReceive = new ObjectName(BEANNAMEFOROFPORTBYTESRECEIVE);
  63             mbeanForEntriesPerOFTable = new ObjectName(BEANNAMEFORENTRIESPEROFTABLE);
  64         } catch (MalformedObjectNameException e) {
  65             logger.error("ObjectName instance creation failed with exception {}", e);
  66
  67         }
  68     }
  69
  70     public void registerMbean() {
  71         try {
  72             // Uniquely identify the MBeans and register them with the platform MBeanServer
  73             if(!mbServer.isRegistered(mbeanForOFPortDuration)) {
  74                 mbServer.registerMBean(counterForOFPortDurationBean, mbeanForOFPortDuration);
  75                 logger.info("Registered Mbean {} successfully", mbeanForOFPortDuration);
  76             }
  77             if(!mbServer.isRegistered(mbeanForOFPortReceiveDrop)) {
  78                 mbServer.registerMBean(counterForOFPortReceiveDropBean, mbeanForOFPortReceiveDrop);
  79                 logger.info("Registered Mbean {} successfully", mbeanForOFPortReceiveDrop);
  80             }
  81             if(!mbServer.isRegistered(mbeanForOFPortReceiveError)) {
  82                 mbServer.registerMBean(counterForOFPortReceiveErrorBean, mbeanForOFPortReceiveError);
  83                 logger.info("Registered Mbean {} successfully", mbeanForOFPortReceiveError);
  84             }
  85             if(!mbServer.isRegistered(mbeanForOFPortPacketSent)) {
  86                 mbServer.registerMBean(counterForOFPortPacketSent, mbeanForOFPortPacketSent);
  87                 logger.info("Registered Mbean {} successfully", mbeanForOFPortPacketSent);
  88             }
  89             if(!mbServer.isRegistered(mbeanForOFPortPacketReceive)) {
  90                 mbServer.registerMBean(counterForOFPortPacketReceive, mbeanForOFPortPacketReceive);
  91                 logger.info("Registered Mbean {} successfully", mbeanForOFPortPacketReceive);
  92             }
  93             if(!mbServer.isRegistered(mbeanForOFPortBytesSent)) {
  94                 mbServer.registerMBean(counterForOFPortBytesSent, mbeanForOFPortBytesSent);
  95                 logger.info("Registered Mbean {} successfully", mbeanForOFPortBytesSent);
  96             }
  97             if(!mbServer.isRegistered(mbeanForOFPortBytesReceive)) {
  98                 mbServer.registerMBean(counterForOFPortBytesReceive, mbeanForOFPortBytesReceive);
  99                 logger.info("Registered Mbean {} successfully", mbeanForOFPortBytesReceive);
 100             }
 101             if(!mbServer.isRegistered(mbeanForEntriesPerOFTable)) {
 102                 mbServer.registerMBean(counterForEntriesPerOFTable, mbeanForEntriesPerOFTable);
 103                 logger.info("Registered Mbean {} successfully", mbeanForEntriesPerOFTable);
 104             }
 105         } catch(Exception e) {
 106             logger.error("Registeration failed with exception {}", e);
 107         }
 108     }
 109
 110
 111     public synchronized void connectToPMAgent(Map<String, String> ofPortDurationCounter, Map<String, String> ofPortReceiveDropCounter,
 112             Map<String, String> ofPortReceiveErrorCounter, Map<String, String> ofPortPacketSent, Map<String, String> ofPortPacketReceive,
 113             Map<String, String> ofPortBytesSent, Map<String, String> ofPortBytesReceive) {
 114         try {
 115                 mbServer.invoke(mbeanForOFPortDuration, "invokePMManagedObjects", new Object[]{ofPortDurationCounter}, new String[]{Map.class.getName()});
 116                 mbServer.invoke(mbeanForOFPortReceiveDrop, "invokePMManagedObjects", new Object[]{ofPortReceiveDropCounter}, new String[]{Map.class.getName()});
 117                 mbServer.invoke(mbeanForOFPortReceiveError, "invokePMManagedObjects", new Object[]{ofPortReceiveErrorCounter}, new String[]{Map.class.getName()});
 118                 mbServer.invoke(mbeanForOFPortPacketSent, "invokePMManagedObjects", new Object[]{ofPortPacketSent}, new String[]{Map.class.getName()});
 119                 mbServer.invoke(mbeanForOFPortPacketReceive, "invokePMManagedObjects", new Object[]{ofPortPacketReceive}, new String[]{Map.class.getName()});
 120                 mbServer.invoke(mbeanForOFPortBytesSent, "invokePMManagedObjects", new Object[]{ofPortBytesSent}, new String[]{Map.class.getName()});
 121                 mbServer.invoke(mbeanForOFPortBytesReceive, "invokePMManagedObjects", new Object[]{ofPortBytesReceive}, new String[]{Map.class.getName()});
 122         } catch (InstanceNotFoundException e ) {
 123             logger.error(" InstanceNotFoundException ", e);
 124         } catch (MBeanException e) {
 125             logger.error(" MBeanException ", e);
 126         } catch (ReflectionException e) {
 127             logger.error(" ReflectionException ", e);
 128         }
 129     }
 130
 131     public synchronized void connectToPMAgentAndInvokeEntriesPerOFTable(Map<String, String> entriesPerOFTable) {
 132         try {
 133                 mbServer.invoke(mbeanForEntriesPerOFTable, "invokePMManagedObjects", new Object[]{entriesPerOFTable}, new String[]{Map.class.getName()});
 134         } catch (InstanceNotFoundException e ) {
 135             logger.error(" InstanceNotFoundException ", e);
 136         } catch (MBeanException e) {
 137             logger.error(" MBeanException ", e);
 138         } catch (ReflectionException e) {
 139             logger.error(" ReflectionException ", e);
 140         }
 141     }
 142 }