MBeanIntrospector.java

/* 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *    http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */
package org.apache.felix.mosgi.jmx.agent.mx4j.server;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.HashMap;

import javax.management.DynamicMBean;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanConstructorInfo;
import javax.management.MBeanInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.MBeanParameterInfo;
import javax.management.NotificationBroadcaster;
import javax.management.loading.MLet;

import org.apache.felix.mosgi.jmx.agent.mx4j.MBeanDescription;
import org.apache.felix.mosgi.jmx.agent.mx4j.MBeanDescriptionAdapter;
import org.apache.felix.mosgi.jmx.agent.mx4j.MX4JSystemKeys;
import org.apache.felix.mosgi.jmx.agent.mx4j.log.Log;
import org.apache.felix.mosgi.jmx.agent.mx4j.log.Logger;
import org.apache.felix.mosgi.jmx.agent.mx4j.util.Utils;

/**
 * Introspector for MBeans. <p>
 * Main purposes of this class are:
 * <ul>
 * <li> Given an mbean, gather all information regarding it into a {@link MBeanMetaData} instance, see {@link #introspect}
 * <li> Given an introspected MBeanMetaData, decide if the MBean is compliant or not.
 * <li> Act as a factory for {@link MBeanInvoker}s
 * </ul>
 *
 * The following system properties are used to control this class' behavior:
 * <ul>
 * <li> mx4j.strict.mbean.interface, if set to 'no' then are treated as standard MBeans also classes that implement
 * management interfaces beloging to different packages or that are inner classes; otherwise are treated as MBeans
 * only classes that implement interfaces whose name if the fully qualified name of the MBean class + "MBean"
 * <li> mx4j.mbean.invoker, if set to the qualified name of an implementation of the {@link MBeanInvoker} interface,
 * then an instance of the class will be used to invoke methods on standard MBeans. By default the generated-on-the-fly
 * MBeanInvoker is used; to revert to the version that uses reflection, for example,
 * use mx4j.mbean.invoker = {@link ReflectedMBeanInvoker mx4j.server.ReflectedMBeanInvoker}
 * </ul>
 *
 * @author <a href="mailto:biorn_steedom@users.sourceforge.net">Simone Bordet</a>
 * @version $Revision: 1.1.1.1 $
 */
public class MBeanIntrospector
{
   private static MBeanDescriptionAdapter DEFAULT_DESCRIPTION = new MBeanDescriptionAdapter();

   private boolean m_useExtendedMBeanInterfaces = false;
   private boolean m_bcelClassesAvailable = false;
   private final String m_customMBeanInvoker;

   public MBeanIntrospector()
   {
      String strict = (String)AccessController.doPrivileged(new PrivilegedAction()
      {
         public Object run()
         {
            return System.getProperty(MX4JSystemKeys.MX4J_STRICT_MBEAN_INTERFACE);
         }
      });
      if (strict != null && !Boolean.valueOf(strict).booleanValue())
      {
         m_useExtendedMBeanInterfaces = true;
      }

      // Try to see if BCEL classes are present
   /* SFR : removed BCEL management
      try
      {
         getClass().getClassLoader().loadClass("org.apache.bcel.generic.Type");
         m_bcelClassesAvailable = true;
      }
      catch (Throwable ignored)
      {
      }
   */

      // See if someone specified which MBean invoker to use
      m_customMBeanInvoker = (String)AccessController.doPrivileged(new PrivilegedAction()
      {
         public Object run()
         {
            return System.getProperty(MX4JSystemKeys.MX4J_MBEAN_INVOKER);
         }
      });
   }

   /**
    * Introspect the given mbean, storing the results in the given metadata.
    * It expects that the mbean field and the classloader field are not null
    * @see #isMBeanCompliant
    */
   public void introspect(MBeanMetaData metadata)
   {
      introspectType(metadata);
      introspectMBeanInfo(metadata);
   }

   /**
    * Returns whether the given already introspected metadata is compliant.
    * Must be called after {@link #introspect}
    */
   public boolean isMBeanCompliant(MBeanMetaData metadata)
   {
      return isMBeanClassCompliant(metadata) && isMBeanTypeCompliant(metadata) && isMBeanInfoCompliant(metadata);
   }

   /**
    * Used by the test cases, invoked via reflection, keep it private.
    * Introspect the mbean and returns if it's compliant
    */
   private boolean testCompliance(MBeanMetaData metadata)
   {
      introspect(metadata);
      return isMBeanCompliant(metadata);
   }

   private boolean isMBeanClassCompliant(MBeanMetaData metadata)
   {
      // From JMX 1.1: no requirements (can be abstract, non public and no accessible constructors)
      return true;
   }

   private boolean isMBeanTypeCompliant(MBeanMetaData metadata)
   {
      Logger logger = getLogger();

      if (metadata.standard && metadata.dynamic)
      {
         if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBean is both standard and dynamic");
         return false;
      }
      if (!metadata.standard && !metadata.dynamic)
      {
         if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBean is not standard nor dynamic");
         return false;
      }

      return true;
   }

   private boolean isMBeanInfoCompliant(MBeanMetaData metadata)
   {
      Logger logger = getLogger();

      if (metadata.info == null)
      {
         if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBeanInfo is null");
         return false;
      }
      return true;
   }

   private void introspectType(MBeanMetaData metadata)
   {
      // Some information is already provided (StandardMBean)
      if (metadata.standard)
      {
         introspectStandardMBean(metadata);
         return;
      }

      if (metadata.mbean instanceof DynamicMBean)
      {
         metadata.dynamic = true;
         return;
      }
      else
      {
         metadata.dynamic = false;
         // Continue and see if it's a plain standard MBean
      }

      // We have a plain standard MBean, introspect it
      introspectStandardMBean(metadata);
   }

   private void introspectStandardMBean(MBeanMetaData metadata)
   {
      if (metadata.management != null)
      {
         // Be sure the MBean implements the management interface
         if (metadata.management.isInstance(metadata.mbean))
         {
            if (metadata.invoker == null) metadata.invoker = createInvoker(metadata);
            return;
         }
         else
         {
            // Not compliant, reset the values
            metadata.standard = false;
            metadata.management = null;
            metadata.invoker = null;
            return;
         }
      }
      else
      {
         Class cls = metadata.mbean.getClass();
         for (Class c = cls; c != null; c = c.getSuperclass())
         {
            Class[] intfs = c.getInterfaces();
            for (int i = 0; i < intfs.length; ++i)
            {
               Class intf = intfs[i];

               if (implementsMBean(c.getName(), intf.getName()))
               {
                  // OK, found the MBean interface for this class
                  metadata.standard = true;
                  metadata.management = intf;
                  metadata.invoker = createInvoker(metadata);
                  return;
               }
            }
         }

         // Management interface not found, it's not compliant, reset the values
         metadata.standard = false;
         metadata.management = null;
         metadata.invoker = null;
      }
   }

   private void introspectMBeanInfo(MBeanMetaData metadata)
   {
      if (metadata.dynamic)
      {
         metadata.info = getDynamicMBeanInfo(metadata);
      }
      else if (metadata.standard)
      {
         metadata.info = createStandardMBeanInfo(metadata);
      }
      else
      {
         // Not a valid MBean, reset the MBeanInfo: this will cause an exception later
         metadata.info = null;
      }
   }

   private MBeanInfo getDynamicMBeanInfo(MBeanMetaData metadata)
   {
      Logger logger = getLogger();

      MBeanInfo info = null;
      
	  try {
		 info = ((DynamicMBean) metadata.mbean).getMBeanInfo();
	  } catch (Exception x) {
	     if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("getMBeanInfo threw: " + x.toString());
	  }
	  
      if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Dynamic MBeanInfo is: " + info);

      if (info == null)
      {
         if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBeanInfo cannot be null");
         return null;
      }

      return info;
   }

   private MBeanInfo createStandardMBeanInfo(MBeanMetaData metadata)
   {
      // This is a non-standard extension: description for standard MBeans
      MBeanDescription description = createMBeanDescription(metadata);

      MBeanConstructorInfo[] ctors = createMBeanConstructorInfo(metadata, description);
      if (ctors == null) return null;
      MBeanAttributeInfo[] attrs = createMBeanAttributeInfo(metadata, description);
      if (attrs == null) return null;
      MBeanOperationInfo[] opers = createMBeanOperationInfo(metadata, description);
      if (opers == null) return null;
      MBeanNotificationInfo[] notifs = createMBeanNotificationInfo(metadata);
      if (notifs == null) return null;

      return new MBeanInfo(metadata.mbean.getClass().getName(), description.getMBeanDescription(), attrs, ctors, opers, notifs);
   }

   private MBeanDescription createMBeanDescription(MBeanMetaData metadata)
   {
      // This is a non-standard extension

      Logger logger = getLogger();
      if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Looking for standard MBean description...");

      Class mbeanClass = metadata.mbean.getClass();

      for (Class cls = mbeanClass; cls != null; cls = cls.getSuperclass())
      {
         String clsName = cls.getName();
         if (clsName.startsWith("java.")) break;

         // Use full qualified name only
         String descrClassName = clsName + "MBeanDescription";
         // Try to load the class
         try
         {
            Class descrClass = null;
            ClassLoader loader = metadata.classloader;
            if (loader != null)
            {
               // Optimize lookup of the description class in case of MLets: we lookup the description class
               // only in the classloader of the mbean, not in the whole CLR (since MLets delegates to the CLR)
               if (loader.getClass() == MLet.class)
                  descrClass = ((MLet)loader).loadClass(descrClassName, null);
               else
                  descrClass = loader.loadClass(descrClassName);
            }
            else
            {
               descrClass = Class.forName(descrClassName, false, null);
            }

            Object descrInstance = descrClass.newInstance();
            if (descrInstance instanceof MBeanDescription)
            {
               MBeanDescription description = (MBeanDescription)descrInstance;
               if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Found provided standard MBean description: " + description);
               return description;
            }
         }
         catch (ClassNotFoundException ignored)
         {
         }
         catch (InstantiationException ignored)
         {
         }
         catch (IllegalAccessException ignored)
         {
         }
      }

      MBeanDescription description = DEFAULT_DESCRIPTION;
      if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Cannot find standard MBean description, using default: " + description);
      return description;
   }

   private MBeanOperationInfo[] createMBeanOperationInfo(MBeanMetaData metadata, MBeanDescription description)
   {
      ArrayList operations = new ArrayList();

      Method[] methods = metadata.management.getMethods();
      for (int j = 0; j < methods.length; ++j)
      {
         Method method = methods[j];
         if (!Utils.isAttributeGetter(method) && !Utils.isAttributeSetter(method))
         {
            String descr = description == null ? null : description.getOperationDescription(method);
            Class[] params = method.getParameterTypes();
            MBeanParameterInfo[] paramsInfo = new MBeanParameterInfo[params.length];
            for (int k = 0; k < params.length; ++k)
            {
               Class param = params[k];
               String paramName = description == null ? null : description.getOperationParameterName(method, k);
               String paramDescr = description == null ? null : description.getOperationParameterDescription(method, k);
               paramsInfo[k] = new MBeanParameterInfo(paramName, param.getName(), paramDescr);
            }
            MBeanOperationInfo info = new MBeanOperationInfo(method.getName(), descr, paramsInfo, method.getReturnType().getName(), MBeanOperationInfo.UNKNOWN);
            operations.add(info);
         }
      }

      return (MBeanOperationInfo[])operations.toArray(new MBeanOperationInfo[operations.size()]);
   }

   private MBeanAttributeInfo[] createMBeanAttributeInfo(MBeanMetaData metadata, MBeanDescription description)
   {
      Logger logger = getLogger();

      HashMap attributes = new HashMap();
      HashMap getterNames = new HashMap();

      Method[] methods = metadata.management.getMethods();
      for (int j = 0; j < methods.length; ++j)
      {
         Method method = methods[j];
         if (Utils.isAttributeGetter(method))
         {
            String name = method.getName();
            boolean isIs = name.startsWith("is");

            String attribute = null;
            if (isIs)
               attribute = name.substring(2);
            else
               attribute = name.substring(3);

            String descr = description == null ? null : description.getAttributeDescription(attribute);

            MBeanAttributeInfo info = (MBeanAttributeInfo)attributes.get(attribute);

            if (info != null)
            {
               // JMX spec does not allow overloading attributes.
               // If an attribute with the same name already exists the MBean is not compliant
               if (!info.getType().equals(method.getReturnType().getName()))
               {
                  if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBean is not compliant: has overloaded attribute " + attribute);
                  return null;
               }
               else
               {
                  // They return the same value, 
                  if (getterNames.get(name) != null)
                  {
                  	// This is the case of an attribute being present in multiple interfaces
                  	// Ignore all but the first, since they resolve to the same method anyways
                 	continue;                  	 
                  }
                  
				  // there is a chance that one is a get-getter and one is a is-getter
				  // for a boolean attribute. In this case, the MBean is not compliant.
                  if (info.isReadable())
                  {
                     if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBean is not compliant: has overloaded attribute " + attribute);
                     return null;
                  }

                  // MBeanAttributeInfo is already present due to a setter method, just update its readability
                  info = new MBeanAttributeInfo(attribute, info.getType(), info.getDescription(), true, info.isWritable(), isIs);
               }
            }
            else
            {
               info = new MBeanAttributeInfo(attribute, method.getReturnType().getName(), descr, true, false, isIs);
            }

            // Replace if exists
            attributes.put(attribute, info);
			getterNames.put(name,method);
         }
         else if (Utils.isAttributeSetter(method))
         {
            String name = method.getName();
            String attribute = name.substring(3);

            String descr = description == null ? null : description.getAttributeDescription(attribute);

            MBeanAttributeInfo info = (MBeanAttributeInfo)attributes.get(attribute);

            if (info != null)
            {
               // JMX spec does not allow overloading attributes.
               // If an attribute with the same name already exists the MBean is not compliant
               if (!info.getType().equals(method.getParameterTypes()[0].getName()))
               {
                  if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("MBean is not compliant: has overloaded attribute " + attribute);
                  return null;
               }
               else
               {
                  // MBeanAttributeInfo is already present due to a getter method, just update its writability
                  info = new MBeanAttributeInfo(info.getName(), info.getType(), info.getDescription(), info.isReadable(), true, info.isIs());
               }
            }
            else
            {
               info = new MBeanAttributeInfo(attribute, method.getParameterTypes()[0].getName(), descr, false, true, false);
            }

            // Replace if exists
            attributes.put(attribute, info);
         }
      }

      return (MBeanAttributeInfo[])attributes.values().toArray(new MBeanAttributeInfo[attributes.size()]);
   }

   private MBeanNotificationInfo[] createMBeanNotificationInfo(MBeanMetaData metadata)
   {
      MBeanNotificationInfo[] notifs = null;
      if (metadata.mbean instanceof NotificationBroadcaster)
      {
         notifs = ((NotificationBroadcaster)metadata.mbean).getNotificationInfo();
      }
      if (notifs == null) notifs = new MBeanNotificationInfo[0];
      return notifs;
   }

   private MBeanConstructorInfo[] createMBeanConstructorInfo(MBeanMetaData metadata, MBeanDescription descrs)
   {
      Class mbeanClass = metadata.mbean.getClass();

      Constructor[] ctors = mbeanClass.getConstructors();
      MBeanConstructorInfo[] constructors = new MBeanConstructorInfo[ctors.length];
      for (int i = 0; i < ctors.length; ++i)
      {
         Constructor constructor = ctors[i];
         String descr = descrs == null ? null : descrs.getConstructorDescription(constructor);
         Class[] params = constructor.getParameterTypes();
         MBeanParameterInfo[] paramsInfo = new MBeanParameterInfo[params.length];
         for (int j = 0; j < params.length; ++j)
         {
            Class param = params[j];
            String paramName = descrs == null ? null : descrs.getConstructorParameterName(constructor, j);
            String paramDescr = descrs == null ? null : descrs.getConstructorParameterDescription(constructor, j);
            paramsInfo[j] = new MBeanParameterInfo(paramName, param.getName(), paramDescr);
         }

         String ctorName = constructor.getName();
         MBeanConstructorInfo info = new MBeanConstructorInfo(ctorName.substring(ctorName.lastIndexOf('.') + 1), descr, paramsInfo);
         constructors[i] = info;
      }
      return constructors;
   }

   private boolean implementsMBean(String clsName, String intfName)
   {
      if (intfName.equals(clsName + "MBean")) return true;

      if (m_useExtendedMBeanInterfaces)
      {
         // Check also that the may be in different packages and/or inner classes

         // Trim packages
         int clsDot = clsName.lastIndexOf('.');
         if (clsDot > 0) clsName = clsName.substring(clsDot + 1);
         int intfDot = intfName.lastIndexOf('.');
         if (intfDot > 0) intfName = intfName.substring(intfDot + 1);
         // Try again
         if (intfName.equals(clsName + "MBean")) return true;

         // Trim inner classes
         int clsDollar = clsName.lastIndexOf('$');
         if (clsDollar > 0) clsName = clsName.substring(clsDollar + 1);
         int intfDollar = intfName.lastIndexOf('$');
         if (intfDollar > 0) intfName = intfName.substring(intfDollar + 1);
         // Try again
         if (intfName.equals(clsName + "MBean")) return true;
      }

      // Give up
      return false;
   }

   private MBeanInvoker createInvoker(MBeanMetaData metadata)
   {
      Logger logger = getLogger();

      if (m_customMBeanInvoker != null)
      {
         if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Custom MBeanInvoker class is: " + m_customMBeanInvoker);
         try
         {
            MBeanInvoker mbeanInvoker = (MBeanInvoker)Thread.currentThread().getContextClassLoader().loadClass(m_customMBeanInvoker).newInstance();
            if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Using custom MBeanInvoker: " + mbeanInvoker);
            return mbeanInvoker;
         }
         catch (Exception x)
         {
            if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("Cannot instantiate custom MBeanInvoker, using default", x);
         }
      }

/* SFR
      if (m_bcelClassesAvailable)
      {
         MBeanInvoker mbeanInvoker = BCELMBeanInvoker.create(metadata);
         if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Using default BCEL MBeanInvoker for MBean " + metadata.name + ", " + mbeanInvoker);
         return mbeanInvoker;
      }
      else
      {
*/
         MBeanInvoker mbeanInvoker = new ReflectedMBeanInvoker();
         if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Using default Reflection MBeanInvoker for MBean " + metadata.name + ", " + mbeanInvoker);
         return mbeanInvoker;
/* SFR     } */
   }

   private Logger getLogger()
   {
      return Log.getLogger(getClass().getName());
   }
}