/* * @(#)BaseMetaDataImpl.java 1.16 05/05/27 * * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package com.sun.jmx.mbeanserver; // java import import java.util.Iterator; import java.io.PrintWriter; import java.io.StringWriter; // RI import import javax.management.* ; import com.sun.jmx.trace.Trace; /** * The DynamicMetaDataImpl class provides local access to the metadata * service in an agent. * The DynamicMetaDataImpl only handles DynamicMBeans. * * @since 1.5 * @since.unbundled JMX RI 1.2 */ abstract class BaseMetaDataImpl implements MetaData { /** The name of this class to be used for tracing */ private final static String dbgTag = "BaseMetaDataImpl"; /** * Creates a Metadata Service. */ BaseMetaDataImpl() { // ------------------------------ // ------------------------------ } //--------------------------------------------------------------------- // // From the MetaData interface // //--------------------------------------------------------------------- public abstract MBeanInfo getMBeanInfo(Object moi) throws IntrospectionException; public abstract Object getAttribute(Object instance, String attribute) throws MBeanException, AttributeNotFoundException, ReflectionException; public abstract AttributeList getAttributes(Object instance, String[] attributes) throws ReflectionException; public abstract AttributeList setAttributes(Object instance, AttributeList attributes) throws ReflectionException; public abstract Object setAttribute(Object instance, Attribute attribute) throws AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException; public abstract Object invoke(Object instance, String operationName, Object params[], String signature[]) throws MBeanException, ReflectionException; public ObjectName preRegisterInvoker(Object moi, ObjectName name, MBeanServer mbs) throws InstanceAlreadyExistsException, MBeanRegistrationException { if (!(moi instanceof MBeanRegistration)) return name; final ObjectName newName; try { newName=(ObjectName) ((MBeanRegistration)moi).preRegister(mbs, name); } catch (RuntimeException e) { throw new RuntimeMBeanException((RuntimeException)e, "RuntimeException thrown in preRegister method"); } catch (Error er) { throw new RuntimeErrorException((Error) er, "Error thrown in preRegister method"); } catch (MBeanRegistrationException r) { throw (MBeanRegistrationException)r; } catch (Exception ex) { throw new MBeanRegistrationException((Exception) ex, "Exception thrown in preRegister method"); } if (newName != null) return newName; else return name; } public void postRegisterInvoker(Object moi, boolean registrationDone) { if (!(moi instanceof MBeanRegistration)) return; try { ((MBeanRegistration)moi). postRegister(new Boolean(registrationDone)); } catch (RuntimeException e) { throw new RuntimeMBeanException((RuntimeException)e, "RuntimeException thrown in postRegister method"); } catch (Error er) { throw new RuntimeErrorException((Error) er, "Error thrown in postRegister method"); } } public void preDeregisterInvoker(Object moi) throws MBeanRegistrationException { if (!(moi instanceof MBeanRegistration)) return; try { ((MBeanRegistration)moi).preDeregister(); } catch (RuntimeException e) { throw new RuntimeMBeanException((RuntimeException) e, "RuntimeException thrown in preDeregister method"); } catch (Error er) { throw new RuntimeErrorException((Error) er, "Error thrown in preDeregister method"); } catch (MBeanRegistrationException t) { throw (MBeanRegistrationException)t; } catch (Exception ex) { throw new MBeanRegistrationException((Exception)ex, "Exception thrown in preDeregister method"); } } public void postDeregisterInvoker(Object moi) { if (!(moi instanceof MBeanRegistration)) return; try { ((MBeanRegistration)moi).postDeregister(); } catch (RuntimeException e) { throw new RuntimeMBeanException((RuntimeException)e, "RuntimeException thrown in postDeregister method"); } catch (Error er) { throw new RuntimeErrorException((Error) er, "Error thrown in postDeregister method"); } } public String getMBeanClassName(Object moi) throws IntrospectionException, NotCompliantMBeanException { final MBeanInfo mbi; try { // Ask the MBeanInfo for the class name mbi = getMBeanInfo(moi); } catch (SecurityException x) { throw x; } catch (IntrospectionException x) { throw x; } catch (Exception x) { throw new NotCompliantMBeanException("Can't obtain MBeanInfo " + "from DynamicMBean: " + x); } if (mbi == null) { throw new NotCompliantMBeanException("The MBeanInfo returned is null"); } final String className = mbi.getClassName(); if (className == null) { throw new IntrospectionException("The class Name returned is null"); } return className; } public boolean isInstanceOf(Object instance, String className) throws ReflectionException { try { final String cn = getMBeanClassName(instance); if (cn.equals(className)) return true; try { final ClassLoader cl = instance.getClass().getClassLoader(); final Class classNameClass = findClass(className,cl); if (classNameClass == null) return false; if (classNameClass.isInstance(instance)) return true; final Class instanceClass = findClass(cn,cl); if (instanceClass == null) return false; return classNameClass.isAssignableFrom(instanceClass); } catch (Exception x) { /* Could be SecurityException or ClassNotFoundException */ debugX("isInstanceOf",x); return false; } } catch (IntrospectionException x) { debugX("isInstanceOf",x); throw new ReflectionException(x,x.getMessage()); } catch (NotCompliantMBeanException x) { debugX("isInstanceOf",x); throw new ReflectionException(x,x.getMessage()); } } Class findClass(String className, ClassLoader loader) throws ReflectionException { try { if (loader == null) return Class.forName(className); else return loader.loadClass(className); } catch (ClassNotFoundException x) { throw new ReflectionException(x,x.getMessage()); } } // 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); } } }