/* * @(#)MetaDataImpl.java 1.28 03/12/19 * * Copyright 2004 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package com.sun.jmx.mbeanserver; // java import import java.lang.reflect.Method; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.util.Hashtable; import java.util.Iterator; import java.io.PrintWriter; import java.io.StringWriter; // RI import import javax.management.* ; import com.sun.jmx.trace.Trace; /** * The MetaData class provides local access to the metadata service in * an agent. * * @since 1.5 * @since.unbundled JMX RI 1.2 */ public class MetaDataImpl implements MetaData { /** The name of this class to be used for tracing */ private final static String dbgTag = "MetaDataImpl"; /** MetaData for DynamicMBeans **/ private final DynamicMetaDataImpl dynamic; private final StandardMetaDataImpl standard; /** * The MBeanInstantiator associated to the MetaData */ protected final MBeanInstantiator instantiator; // Not sure we need this... private final class PrivateStandardMeta extends StandardMetaDataImpl { PrivateStandardMeta() { super(); } // public synchronized void testCompliance(Class c) { // MetaDataImpl.this.testStrictCompliance(c); // } protected Class findClass(String className, ClassLoader loader) throws ReflectionException { return MetaDataImpl.this.findClass(className,loader); } protected Class[] findSignatureClasses(String[] signature, ClassLoader loader) throws ReflectionException { return MetaDataImpl.this.findSignatureClasses(signature,loader); } } // Not sure we need this... private final class PrivateDynamicMeta extends DynamicMetaDataImpl { PrivateDynamicMeta() { super(); } // public synchronized void testCompliance(Class c) { // MetaDataImpl.this.testStrictCompliance(c); // } protected Class findClass(String className, ClassLoader loader) throws ReflectionException { return MetaDataImpl.this.findClass(className,loader); } protected Class[] findSignatureClasses(String[] signature, ClassLoader loader) throws ReflectionException { return MetaDataImpl.this.findSignatureClasses(signature,loader); } } /** * Creates a Metadata Service. * @param instantiator The MBeanInstantiator that will be used to * take care of class loading issues. * This parameter may not be null. * @exception IllegalArgumentException if the instantiator is null. */ public MetaDataImpl(MBeanInstantiator instantiator) { if (instantiator == null) throw new IllegalArgumentException("instantiator must not be null."); this.instantiator = instantiator; this.dynamic = new PrivateDynamicMeta(); this.standard = new PrivateStandardMeta(); // ------------------------------ // ------------------------------ } protected MetaData getMetaData(Class c) { if (DynamicMBean.class.isAssignableFrom(c)) return dynamic; else return standard; } protected MetaData getMetaData(Object moi) { if (moi instanceof DynamicMBean) return dynamic; else return standard; } /** * This methods tests if the MBean is JMX compliant */ public synchronized void testCompliance(Class c) throws NotCompliantMBeanException { final MetaData meta = getMetaData(c); meta.testCompliance(c); } /** * This methods returns the MBean interface of an MBean */ public Class getMBeanInterfaceFromClass(Class c) { return standard.getMBeanInterfaceFromClass(c); } /** * This method discovers the attributes and operations that an MBean * exposes for management. * * @param beanClass The class to be analyzed. * * @return An instance of MBeanInfo allowing to retrieve all methods * and operations of this class. * * @exception IntrospectionException if an exception occurs during * introspection. * @exception NotCompliantMBeanException if the MBean class is not * MBean compliant. * */ public MBeanInfo getMBeanInfoFromClass(Class beanClass) throws IntrospectionException, NotCompliantMBeanException { return standard.getMBeanInfoFromClass(beanClass); } //--------------------------------------------------------------------- // // From the MetaData interface // //--------------------------------------------------------------------- public final String getMBeanClassName(Object moi) throws IntrospectionException, NotCompliantMBeanException { final MetaData meta = getMetaData(moi); return meta.getMBeanClassName(moi); } public final MBeanInfo getMBeanInfo(Object moi) throws IntrospectionException { final MetaData meta = getMetaData(moi); return meta.getMBeanInfo(moi); } public final Object getAttribute(Object instance, String attribute) throws MBeanException, AttributeNotFoundException, ReflectionException { final MetaData meta = getMetaData(instance); return meta.getAttribute(instance,attribute); } public final AttributeList getAttributes(Object instance, String[] attributes) throws ReflectionException { final MetaData meta = getMetaData(instance); return meta.getAttributes(instance, attributes); } public final AttributeList setAttributes(Object instance, AttributeList attributes) throws ReflectionException { final MetaData meta = getMetaData(instance); return meta.setAttributes(instance,attributes); } public final Object setAttribute(Object instance, Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException { final MetaData meta = getMetaData(instance); return meta.setAttribute(instance,attribute); } public final Object invoke(Object instance, String operationName, Object params[], String signature[]) throws MBeanException, ReflectionException { if (operationName == null) { final RuntimeException r = new IllegalArgumentException("Operation name cannot be null"); throw new RuntimeOperationsException(r, "Exception occured trying to invoke the operation on the MBean"); } final MetaData meta = getMetaData(instance); return meta.invoke(instance,operationName,params,signature); } public boolean isInstanceOf(Object instance, String className) throws ReflectionException { // XXX revisit here: ModelMBean ??? final MetaData meta = getMetaData(instance); return meta.isInstanceOf(instance,className); } public ObjectName preRegisterInvoker(Object moi, ObjectName name, MBeanServer mbs) throws InstanceAlreadyExistsException, MBeanRegistrationException { if (!(moi instanceof MBeanRegistration)) return name; final MetaData meta = getMetaData(moi); return meta.preRegisterInvoker(moi,name,mbs); } public void postRegisterInvoker(Object moi, boolean registrationDone) { if (!(moi instanceof MBeanRegistration)) return; final MetaData meta = getMetaData(moi); meta.postRegisterInvoker(moi,registrationDone); } public void preDeregisterInvoker(Object moi) throws MBeanRegistrationException { if (!(moi instanceof MBeanRegistration)) return; final MetaData meta = getMetaData(moi); meta.preDeregisterInvoker(moi); } public void postDeregisterInvoker(Object moi) { if (!(moi instanceof MBeanRegistration)) return; final MetaData meta = getMetaData(moi); meta.postDeregisterInvoker(moi); } /** * Find a class using the specified ClassLoader. **/ protected Class findClass(String className, ClassLoader loader) throws ReflectionException { return instantiator.findClass(className, loader); } /** * Find the classes from a signature using the specified ClassLoader. **/ protected Class[] findSignatureClasses(String[] signature, ClassLoader loader) throws ReflectionException { return ((signature == null)?null: instantiator.findSignatureClasses(signature,loader)); } // TRACES & DEBUG //--------------- private static boolean isTraceOn() { return Trace.isSelected(Trace.LEVEL_TRACE, Trace.INFO_MBEANSERVER); } private static void trace(String clz, String func, String info) { Trace.send(Trace.LEVEL_TRACE, Trace.INFO_MBEANSERVER, clz, func, info); } private static void trace(String func, String info) { trace(dbgTag, func, info); } private static boolean isDebugOn() { return Trace.isSelected(Trace.LEVEL_DEBUG, Trace.INFO_MBEANSERVER); } private static void debug(String clz, String func, String info) { Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_MBEANSERVER, clz, func, info); } private static void debug(String func, String info) { debug(dbgTag, func, info); } private static void debugX(String func,Throwable e) { if (isDebugOn()) { final StringWriter s = new StringWriter(); e.printStackTrace(new PrintWriter(s)); final String stack = s.toString(); debug(dbgTag,func,"Exception caught in "+ func+"(): "+e); debug(dbgTag,func,stack); // java.lang.System.err.println("**** Exception caught in "+ // func+"(): "+e); // java.lang.System.err.println(stack); } } }