opendaylight/md-sal/sal-common-util/src/main/java/org/opendaylight/controller/md/sal/common/util/jmx/AbstractMXBean.java

   1 /*
   2  * Copyright (c) 2014 Brocade Communications Systems, Inc. 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
   9 package org.opendaylight.controller.md.sal.common.util.jmx;
  10
  11 import com.google.common.annotations.Beta;
  12 import java.lang.management.ManagementFactory;
  13 import javax.annotation.Nonnull;
  14 import javax.annotation.Nullable;
  15 import javax.management.InstanceNotFoundException;
  16 import javax.management.MBeanRegistrationException;
  17 import javax.management.MBeanServer;
  18 import javax.management.MalformedObjectNameException;
  19 import javax.management.ObjectName;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22
  23 /**
  24  * Abstract base for an MXBean implementation class.
  25  * <p>
  26  * This class is not intended for use outside of MD-SAL and its part of private
  27  * implementation (still exported as public to be reused across MD-SAL implementation
  28  * components) and may be removed in subsequent
  29  * releases.
  30  *
  31  * @author Thomas Pantelis
  32  */
  33 @Beta
  34 public abstract class AbstractMXBean {
  35
  36     private static final Logger LOG = LoggerFactory.getLogger(AbstractMXBean.class);
  37
  38     public static String BASE_JMX_PREFIX = "org.opendaylight.controller:";
  39
  40     private final MBeanServer server = ManagementFactory.getPlatformMBeanServer();
  41
  42     private final String mBeanName;
  43     private final String mBeanType;
  44     private final String mBeanCategory;
  45
  46     /**
  47      * Constructor.
  48      *
  49      * @param mBeanName Used as the <code>name</code> property in the bean's ObjectName.
  50      * @param mBeanType Used as the <code>type</code> property in the bean's ObjectName.
  51      * @param mBeanCategory Used as the <code>Category</code> property in the bean's ObjectName.
  52      */
  53     protected AbstractMXBean(@Nonnull String mBeanName, @Nonnull String mBeanType,
  54             @Nullable String mBeanCategory) {
  55         this.mBeanName = mBeanName;
  56         this.mBeanType = mBeanType;
  57         this.mBeanCategory = mBeanCategory;
  58     }
  59
  60     private ObjectName getMBeanObjectName() throws MalformedObjectNameException {
  61         StringBuilder builder = new StringBuilder(BASE_JMX_PREFIX)
  62                 .append("type=").append(getMBeanType());
  63
  64         if(getMBeanCategory() != null) {
  65             builder.append(",Category=").append(getMBeanCategory());
  66         }
  67
  68         builder.append(",name=").append(getMBeanName());
  69         return new ObjectName(builder.toString());
  70     }
  71
  72     /**
  73      * This method is a wrapper for registerMBean with void return type so it can be invoked by dependency
  74      * injection frameworks such as Spring and Blueprint.
  75      */
  76     public void register() {
  77         registerMBean();
  78     }
  79
  80     /**
  81      * Registers this bean with the platform MBean server with the domain defined by
  82      * {@link #BASE_JMX_PREFIX}.
  83      *
  84      * @return true is successfully registered, false otherwise.
  85      */
  86     public boolean registerMBean() {
  87         boolean registered = false;
  88         try {
  89             // Object to identify MBean
  90             final ObjectName mbeanName = this.getMBeanObjectName();
  91
  92             LOG.debug("Register MBean {}", mbeanName);
  93
  94             // unregistered if already registered
  95             if(server.isRegistered(mbeanName)) {
  96
  97                 LOG.debug("MBean {} found to be already registered", mbeanName);
  98
  99                 try {
 100                     unregisterMBean(mbeanName);
 101                 } catch(Exception e) {
 102
 103                     LOG.warn("unregister mbean {} resulted in exception {} ", mbeanName, e);
 104                 }
 105             }
 106             server.registerMBean(this, mbeanName);
 107             registered = true;
 108
 109             LOG.debug("MBean {} registered successfully", mbeanName.getCanonicalName());
 110         } catch(Exception e) {
 111
 112             LOG.error("registration failed {}", e);
 113
 114         }
 115         return registered;
 116     }
 117
 118     /**
 119      * This method is a wrapper for unregisterMBean with void return type so it can be invoked by dependency
 120      * injection frameworks such as Spring and Blueprint.
 121      */
 122     public void unregister() {
 123         unregisterMBean();
 124     }
 125
 126     /**
 127      * Unregisters this bean with the platform MBean server.
 128      *
 129      * @return true is successfully unregistered, false otherwise.
 130      */
 131     public boolean unregisterMBean() {
 132         boolean unregister = false;
 133         try {
 134             ObjectName mbeanName = this.getMBeanObjectName();
 135             unregisterMBean(mbeanName);
 136             unregister = true;
 137         } catch(Exception e) {
 138             LOG.debug("Failed when unregistering MBean {}", e);
 139         }
 140
 141         return unregister;
 142     }
 143
 144     private void unregisterMBean(ObjectName mbeanName) throws MBeanRegistrationException,
 145             InstanceNotFoundException {
 146         server.unregisterMBean(mbeanName);
 147     }
 148
 149     /**
 150      * Returns the <code>name</code> property of the bean's ObjectName.
 151      */
 152     public String getMBeanName() {
 153         return mBeanName;
 154     }
 155
 156     /**
 157      * Returns the <code>type</code> property of the bean's ObjectName.
 158      */
 159     public String getMBeanType() {
 160         return mBeanType;
 161     }
 162
 163     /**
 164      * Returns the <code>Category</code> property of the bean's ObjectName.
 165      */
 166     public String getMBeanCategory() {
 167         return mBeanCategory;
 168     }
 169 }