FileDocCategorySizeDatePackage
JmxMBeanServer.javaAPI DocJava SE 6 API61547Tue Jun 10 00:22:02 BST 2008com.sun.jmx.mbeanserver

JmxMBeanServer

public final class JmxMBeanServer extends Object implements SunJmxMBeanServer
This is the base class for MBean manipulation on the agent side. It contains the methods necessary for the creation, registration, and deletion of MBeans as well as the access methods for registered MBeans. This is the core component of the JMX infrastructure.

Every MBean which is added to the MBean server becomes manageable: its attributes and operations become remotely accessible through the connectors/adaptors connected to that MBean server. A Java object cannot be registered in the MBean server unless it is a JMX compliant MBean.

When an MBean is registered or unregistered in the MBean server an {@link javax.management.MBeanServerNotification MBeanServerNotification} Notification is emitted. To register an object as listener to MBeanServerNotifications you should call the MBean server method {@link #addNotificationListener addNotificationListener} with the ObjectName of the {@link javax.management.MBeanServerDelegate MBeanServerDelegate}. This ObjectName is:
JMImplementation:type=MBeanServerDelegate.

since
1.5

Fields Summary
private static final String
dbgTag
The name of this class to be used for tracing
private final MBeanInstantiator
instantiator
private final SecureClassLoaderRepository
secureClr
private final boolean
interceptorsEnabled
true if interceptors are enabled
private final transient MBeanServer
outerShell
Revisit: transient ???
private transient MBeanServerInterceptor
mbsInterceptor
Revisit: transient ???
private final transient MBeanServerDelegate
mBeanServerDelegateObject
The MBeanServerDelegate object representing the MBean Server
Constructors Summary
JmxMBeanServer(String domain, MBeanServer outer, MBeanServerDelegate delegate)
Package: Creates an MBeanServer with the specified default domain name, outer interface, and delegate.

The default domain name is used as the domain part in the ObjectName of MBeans if no domain is specified by the user.

    Note:Using this constructor directly is strongly discouraged. You should use {@link javax.management.MBeanServerFactory#createMBeanServer(java.lang.String)} or {@link javax.management.MBeanServerFactory#newMBeanServer(java.lang.String)} instead.

    By default, {@link MBeanServerInterceptor} are disabled. Use {@link #JmxMBeanServer(java.lang.String,javax.management.MBeanServer,javax.management.MBeanServerDelegate,boolean)} to enable them.

param
domain The default domain name used by this MBeanServer.
param
outer A pointer to the MBeanServer object that must be passed to the MBeans when invoking their {@link javax.management.MBeanRegistration} interface.
param
delegate A pointer to the MBeanServerDelegate associated with the new MBeanServer. The new MBeanServer must register this MBean in its MBean repository.
exception
IllegalArgumentException if the instantiator is null.


                                                                                                                                                                                                        
        
		     
	this(domain,outer,delegate,null,false);
    
JmxMBeanServer(String domain, MBeanServer outer, MBeanServerDelegate delegate, boolean interceptors)
Package: Creates an MBeanServer with the specified default domain name, outer interface, and delegate.

The default domain name is used as the domain part in the ObjectName of MBeans if no domain is specified by the user.

    Note:Using this constructor directly is strongly discouraged. You should use {@link javax.management.MBeanServerFactory#createMBeanServer(java.lang.String)} or {@link javax.management.MBeanServerFactory#newMBeanServer(java.lang.String)} instead.

param
domain The default domain name used by this MBeanServer.
param
outer A pointer to the MBeanServer object that must be passed to the MBeans when invoking their {@link javax.management.MBeanRegistration} interface.
param
delegate A pointer to the MBeanServerDelegate associated with the new MBeanServer. The new MBeanServer must register this MBean in its MBean repository.
param
interceptors If true, {@link MBeanServerInterceptor} will be enabled (default is false) Note: this parameter is not taken into account by this implementation - the default value false is always used.
exception
IllegalArgumentException if the instantiator is null.

	this(domain,outer,delegate,null,false);
    
JmxMBeanServer(String domain, MBeanServer outer, MBeanServerDelegate delegate, MBeanInstantiator instantiator, boolean interceptors)
Package: Creates an MBeanServer.

param
domain The default domain name used by this MBeanServer.
param
outer A pointer to the MBeanServer object that must be passed to the MBeans when invoking their {@link javax.management.MBeanRegistration} interface.
param
delegate A pointer to the MBeanServerDelegate associated with the new MBeanServer. The new MBeanServer must register this MBean in its MBean repository.
param
instantiator The MBeanInstantiator that will be used to instantiate MBeans and take care of class loading issues.
param
metadata The MetaData object that will be used by the MBean server in order to invoke the MBean interface of the registered MBeans.
param
interceptors If true, {@link MBeanServerInterceptor} will be enabled (default is false).


	if (instantiator == null) {
	    final ModifiableClassLoaderRepository
		clr = new ClassLoaderRepositorySupport();
	    instantiator = new MBeanInstantiator(clr);
	}
	this.secureClr = new 
	  SecureClassLoaderRepository(instantiator.getClassLoaderRepository());
	if (delegate == null) 
	    delegate = new MBeanServerDelegateImpl();
	if (outer == null)
	    outer = this;
	
	this.instantiator = instantiator;
	this.mBeanServerDelegateObject = delegate;
	this.outerShell   = outer;

	final Repository repository = new Repository(domain);
	this.mbsInterceptor = 
	    new DefaultMBeanServerInterceptor(outer, delegate, instantiator, 
					      repository);
	this.interceptorsEnabled = interceptors;
	initialize();
    
Methods Summary
public voidaddNotificationListener(javax.management.ObjectName name, javax.management.NotificationListener listener, javax.management.NotificationFilter filter, java.lang.Object handback)
Adds a listener to a registered MBean.

param
name The name of the MBean on which the listener should be added.
param
listener The listener object which will handle the notifications emitted by the registered MBean.
param
filter The filter object. If filter is null, no filtering will be performed before handling notifications.
param
handback The context to be sent to the listener when a notification is emitted.
exception
InstanceNotFoundException The MBean name provided does not match any of the registered MBeans.


	mbsInterceptor.addNotificationListener(cloneObjectName(name), listener,
					       filter, handback);
    
public voidaddNotificationListener(javax.management.ObjectName name, javax.management.ObjectName listener, javax.management.NotificationFilter filter, java.lang.Object handback)
Adds a listener to a registered MBean.

param
name The name of the MBean on which the listener should be added.
param
listener The object name of the listener which will handle the notifications emitted by the registered MBean.
param
filter The filter object. If filter is null, no filtering will be performed before handling notifications.
param
handback The context to be sent to the listener when a notification is emitted.
exception
InstanceNotFoundException The MBean name of the notification listener or of the notification broadcaster does not match any of the registered MBeans.

	
        mbsInterceptor.addNotificationListener(cloneObjectName(name), listener,
					       filter, handback);
    
private static voidcheckMBeanPermission(java.lang.String classname, java.lang.String member, javax.management.ObjectName objectName, java.lang.String actions)

	SecurityManager sm = System.getSecurityManager();
	if (sm != null) {
	    Permission perm = new MBeanPermission(classname,
						  member,
						  objectName,
						  actions);
	    sm.checkPermission(perm);
	}
    
private javax.management.AttributecloneAttribute(javax.management.Attribute attribute)
Clone attribute.

	if (attribute != null) {
	    if (!attribute.getClass().equals(Attribute.class)) {
		return new Attribute(attribute.getName(), attribute.getValue());
	    }
	}
	return attribute;
    
private javax.management.AttributeListcloneAttributeList(javax.management.AttributeList list)
Clone attribute list.

	if (list != null) {
	    if (!list.getClass().equals(AttributeList.class)) {
		// Create new attribute list
		//
		AttributeList newList = new AttributeList(list.size());

		// Iterate through list and replace non JMX attributes
		//
		for (Iterator i = list.iterator(); i.hasNext(); ) {
		    Attribute attribute = (Attribute) i.next();
		    newList.add(cloneAttribute(attribute));
		}
		return newList;
	    } else {
		// Iterate through list and replace non JMX attributes
		//
		for (int i = 0; i < list.size(); i++) {
		    Attribute attribute = (Attribute) list.get(i);
		    if (!attribute.getClass().equals(Attribute.class)) {
			list.set(i, cloneAttribute(attribute));
		    }
		}
		return list;
	    }
	}
	return list;
    
private javax.management.ObjectNamecloneObjectName(javax.management.ObjectName name)
Clone object name.

	if (name != null) {
	    return ObjectName.getInstance(name);
	}
	return name;
    
public javax.management.ObjectInstancecreateMBean(java.lang.String className, javax.management.ObjectName name)
Instantiates and registers an MBean in the MBean server. The MBean server will use its {@link javax.management.loading.ClassLoaderRepository Default Loader Repository} to load the class of the MBean. An object name is associated to the MBean. If the object name given is null, the MBean can automatically provide its own name by implementing the {@link javax.management.MBeanRegistration MBeanRegistration} interface. The call returns an ObjectInstance object representing the newly created MBean.

param
className The class name of the MBean to be instantiated.
param
name The object name of the MBean. May be null.
return
An ObjectInstance, containing the ObjectName and the Java class name of the newly instantiated MBean.
exception
ReflectionException Wraps an {@link java.lang.ClassNotFoundException} or an {@link java.lang.Exception} that occurred when trying to invoke the MBean's constructor.
exception
InstanceAlreadyExistsException The MBean is already under the control of the MBean server.
exception
MBeanRegistrationException The preRegister() (MBeanRegistration interface) method of the MBean has thrown an exception. The MBean will not be registered.
exception
MBeanException The constructor of the MBean has thrown an exception.
exception
NotCompliantMBeanException This class is not a JMX compliant MBean.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null, the ObjectName passed in parameter contains a pattern or no ObjectName is specified for the MBean.

 

	return mbsInterceptor.createMBean(className,
					  cloneObjectName(name),
					  (Object[]) null,
					  (String[]) null);
    
public javax.management.ObjectInstancecreateMBean(java.lang.String className, javax.management.ObjectName name, javax.management.ObjectName loaderName)
Instantiates and registers an MBean in the MBean server. The class loader to be used is identified by its object name. An object name is associated to the MBean. If the object name of the loader is null, the ClassLoader that loaded the MBean server will be used. If the MBean's object name given is null, the MBean can automatically provide its own name by implementing the {@link javax.management.MBeanRegistration MBeanRegistration} interface. The call returns an ObjectInstance object representing the newly created MBean.

param
className The class name of the MBean to be instantiated.
param
name The object name of the MBean. May be null.
param
loaderName The object name of the class loader to be used.
return
An ObjectInstance, containing the ObjectName and the Java class name of the newly instantiated MBean.
exception
ReflectionException Wraps an {@link java.lang.ClassNotFoundException} or an {@link java.lang.Exception} that occurred when trying to invoke the MBean's constructor.
exception
InstanceAlreadyExistsException The MBean is already under the control of the MBean server.
exception
MBeanRegistrationException The preRegister() (MBeanRegistration interface) method of the MBean has thrown an exception. The MBean will not be registered.
exception
MBeanException The constructor of the MBean has thrown an exception
exception
NotCompliantMBeanException This class is not a JMX compliant MBean.
exception
InstanceNotFoundException The specified class loader is not registered in the MBean server.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null, the ObjectName passed in parameter contains a pattern or no ObjectName is specified for the MBean.

 
	
	return mbsInterceptor.createMBean(className,
					  cloneObjectName(name),
					  loaderName,
 					  (Object[]) null,
					  (String[]) null);
    
public javax.management.ObjectInstancecreateMBean(java.lang.String className, javax.management.ObjectName name, java.lang.Object[] params, java.lang.String[] signature)
Instantiates and registers an MBean in the MBean server. The MBean server will use its {@link javax.management.loading.ClassLoaderRepository Default Loader Repository} to load the class of the MBean. An object name is associated to the MBean. If the object name given is null, the MBean can automatically provide its own name by implementing the {@link javax.management.MBeanRegistration MBeanRegistration} interface. The call returns an ObjectInstance object representing the newly created MBean.

param
className The class name of the MBean to be instantiated.
param
name The object name of the MBean. May be null.
param
params An array containing the parameters of the constructor to be invoked.
param
signature An array containing the signature of the constructor to be invoked.
return
An ObjectInstance, containing the ObjectName and the Java class name of the newly instantiated MBean.
exception
ReflectionException Wraps a {@link java.lang.ClassNotFoundException} or an {@link java.lang.Exception} that occurred when trying to invoke the MBean's constructor.
exception
InstanceAlreadyExistsException The MBean is already under the control of the MBean server.
exception
MBeanRegistrationException The preRegister() (MBeanRegistration interface) method of the MBean has thrown an exception. The MBean will not be registered.
exception
MBeanException The constructor of the MBean has thrown an exception.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null, the ObjectName passed in parameter contains a pattern or no ObjectName is specified for the MBean.

 
	
	return mbsInterceptor.createMBean(className, cloneObjectName(name),
					  params, signature);
    
public javax.management.ObjectInstancecreateMBean(java.lang.String className, javax.management.ObjectName name, javax.management.ObjectName loaderName, java.lang.Object[] params, java.lang.String[] signature)
Instantiates and registers an MBean in the MBean server. The class loader to be used is identified by its object name. An object name is associated to the MBean. If the object name of the loader is not specified, the ClassLoader that loaded the MBean server will be used. If the MBean object name given is null, the MBean can automatically provide its own name by implementing the {@link javax.management.MBeanRegistration MBeanRegistration} interface. The call returns an ObjectInstance object representing the newly created MBean.

param
className The class name of the MBean to be instantiated.
param
name The object name of the MBean. May be null.
param
params An array containing the parameters of the constructor to be invoked.
param
signature An array containing the signature of the constructor to be invoked.
param
loaderName The object name of the class loader to be used.
return
An ObjectInstance, containing the ObjectName and the Java class name of the newly instantiated MBean.
exception
ReflectionException Wraps a {@link java.lang.ClassNotFoundException} or an {@link java.lang.Exception} that occurred when trying to invoke the MBean's constructor.
exception
InstanceAlreadyExistsException The MBean is already under the control of the MBean server.
exception
MBeanRegistrationException The preRegister() (MBeanRegistration interface) method of the MBean has thrown an exception. The MBean will not be registered.
exception
MBeanException The constructor of the MBean has thrown an exception
exception
InstanceNotFoundException The specified class loader is not registered in the MBean server.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null, the ObjectName passed in parameter contains a pattern or no ObjectName is specified for the MBean.

 
     
        return mbsInterceptor.createMBean(className, cloneObjectName(name),
					  loaderName, params, signature);
    
private voiddebug(java.lang.String clz, java.lang.String func, java.lang.String info)

        Trace.send(Trace.LEVEL_DEBUG, Trace.INFO_MBEANSERVER, clz, func, info);
    
private voiddebug(java.lang.String func, java.lang.String info)

        debug(dbgTag, func, info);
    
public java.io.ObjectInputStreamdeserialize(javax.management.ObjectName name, byte[] data)
De-serializes a byte array in the context of the class loader of an MBean.

param
name The name of the MBean whose class loader should be used for the de-serialization.
param
data The byte array to be de-sererialized.
return
The de-serialized object stream.
exception
InstanceNotFoundException The MBean specified is not found.
exception
OperationsException Any of the usual Input/Output related exceptions.


	/* Permission check */
	// This call requires MBeanPermission 'getClassLoaderFor'
	final ClassLoader loader = getClassLoaderFor(name);

	return instantiator.deserialize(loader, data);
    
public java.io.ObjectInputStreamdeserialize(java.lang.String className, byte[] data)
De-serializes a byte array in the context of a given MBean class loader. The class loader is the one that loaded the class with name "className".

param
className The name of the class whose class loader should be used for the de-serialization.
param
data The byte array to be de-sererialized.
return
The de-serialized object stream.
exception
OperationsException Any of the usual Input/Output related exceptions.
exception
ReflectionException The specified class could not be loaded by the default loader repository


        if (className == null) {
            throw new  RuntimeOperationsException(
					new IllegalArgumentException(),
					"Null className passed in parameter");
        }

	/* Permission check */
	// This call requires MBeanPermission 'getClassLoaderRepository'
	final ClassLoaderRepository clr = getClassLoaderRepository();

	Class theClass;
	try {
	    if (clr == null) throw new ClassNotFoundException(className);
	    theClass = clr.loadClass(className);
	} catch (ClassNotFoundException e) {
	    throw new ReflectionException(e,
					  "The given class could not be " +
					  "loaded by the default loader " +
					  "repository");
	}

	return instantiator.deserialize(theClass.getClassLoader(), data);
    
public java.io.ObjectInputStreamdeserialize(java.lang.String className, javax.management.ObjectName loaderName, byte[] data)
De-serializes a byte array in the context of a given MBean class loader. The class loader is the one that loaded the class with name "className". The name of the class loader to be used for loading the specified class is specified. If null, the MBean Server's class loader will be used.

param
className The name of the class whose class loader should be used for the de-serialization.
param
data The byte array to be de-sererialized.
param
loaderName The name of the class loader to be used for loading the specified class. If null, the MBean Server's class loader will be used.
return
The de-serialized object stream.
exception
InstanceNotFoundException The specified class loader MBean is not found.
exception
OperationsException Any of the usual Input/Output related exceptions.
exception
ReflectionException The specified class could not be loaded by the specified class loader.


	// Clone ObjectName
	//
	loaderName = cloneObjectName(loaderName);

	/* Permission check */
	// Make this call just to force the 'getClassLoader'
	// permission check
	try {
	    getClassLoader(loaderName);
	} catch (SecurityException e) {
	    throw e;
	} catch (Exception e) {
	}

	ClassLoader myLoader = outerShell.getClass().getClassLoader();
        return instantiator.deserialize(className, loaderName, data, myLoader);
    
public java.lang.ObjectgetAttribute(javax.management.ObjectName name, java.lang.String attribute)
Gets the value of a specific attribute of a named MBean. The MBean is identified by its object name.

param
name The object name of the MBean from which the attribute is to be retrieved.
param
attribute A String specifying the name of the attribute to be retrieved.
return
The value of the retrieved attribute.
exception
AttributeNotFoundException The attribute specified is not accessible in the MBean.
exception
MBeanException Wraps an exception thrown by the MBean's getter.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.
exception
ReflectionException Wraps an {@link java.lang.Exception} thrown when trying to invoke the setter.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The object name in parameter is null or the attribute in parameter is null.

 

	return mbsInterceptor.getAttribute(cloneObjectName(name), attribute);
    
public javax.management.AttributeListgetAttributes(javax.management.ObjectName name, java.lang.String[] attributes)
Enables the values of several attributes of a named MBean. The MBean is identified by its object name.

param
name The object name of the MBean from which the attributes are retrieved.
param
attributes A list of the attributes to be retrieved.
return
The list of the retrieved attributes.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.
exception
ReflectionException An exception occurred when trying to invoke the getAttributes method of a Dynamic MBean.
exception
RuntimeOperationsException Wrap an {@link java.lang.IllegalArgumentException}: The object name in parameter is null or attributes in parameter is null.

 
  
	return mbsInterceptor.getAttributes(cloneObjectName(name), attributes);
   
    
public java.lang.ClassLoadergetClassLoader(javax.management.ObjectName loaderName)

Return the named {@link java.lang.ClassLoader}.

param
loaderName The ObjectName of the ClassLoader.
return
The named ClassLoader.
exception
InstanceNotFoundException if the named ClassLoader is not found.

	return mbsInterceptor.getClassLoader(cloneObjectName(loaderName));
    
public java.lang.ClassLoadergetClassLoaderFor(javax.management.ObjectName mbeanName)

Return the {@link java.lang.ClassLoader} that was used for loading the class of the named MBean.

param
mbeanName The ObjectName of the MBean.
return
The ClassLoader used for that MBean.
exception
InstanceNotFoundException if the named MBean is not found.

	return mbsInterceptor.getClassLoaderFor(cloneObjectName(mbeanName));
    
public javax.management.loading.ClassLoaderRepositorygetClassLoaderRepository()

Return the ClassLoaderRepository for that MBeanServer.

return
The ClassLoaderRepository for that MBeanServer.

	/* Permission check */
	checkMBeanPermission(null, null, null, "getClassLoaderRepository");
	return secureClr;
    
public java.lang.StringgetDefaultDomain()
Returns the default domain used for naming the MBean. The default domain name is used as the domain part in the ObjectName of MBeans if no domain is specified by the user.

 
        return mbsInterceptor.getDefaultDomain();
    
public java.lang.String[]getDomains()

        return mbsInterceptor.getDomains();
    
public java.lang.IntegergetMBeanCount()
Returns the number of MBeans registered in the MBean server.

 

        return mbsInterceptor.getMBeanCount();
    
public javax.management.MBeanInfogetMBeanInfo(javax.management.ObjectName name)
This method discovers the attributes and operations that an MBean exposes for management.

param
name The name of the MBean to analyze
return
An instance of MBeanInfo allowing the retrieval of all attributes and operations of this MBean.
exception
IntrospectionException An exception occurs during introspection.
exception
InstanceNotFoundException The MBean specified is not found.
exception
ReflectionException An exception occurred when trying to invoke the getMBeanInfo of a Dynamic MBean.

 
	
	return mbsInterceptor.getMBeanInfo(cloneObjectName(name));
    
public com.sun.jmx.mbeanserver.MBeanInstantiatorgetMBeanInstantiator()
Return the MBeanInstantiator associated to this MBeanServer.

exception
UnsupportedOperationException if {@link MBeanServerInterceptor}s are not enabled on this object.
see
#interceptorsEnabled

	if (interceptorsEnabled) return instantiator;
	else throw new UnsupportedOperationException(
	               "MBeanServerInterceptors are disabled.");
    
public javax.management.MBeanServerDelegategetMBeanServerDelegate()

	if (!interceptorsEnabled) throw new UnsupportedOperationException(
	               "MBeanServerInterceptors are disabled.");
	return mBeanServerDelegateObject;
    
public synchronized com.sun.jmx.interceptor.MBeanServerInterceptorgetMBeanServerInterceptor()
Return the MBeanServerInterceptor.

exception
UnsupportedOperationException if {@link MBeanServerInterceptor}s are not enabled on this object.
see
#interceptorsEnabled

	if (interceptorsEnabled) return mbsInterceptor;
	else throw new UnsupportedOperationException(
	               "MBeanServerInterceptors are disabled.");
    
public javax.management.ObjectInstancegetObjectInstance(javax.management.ObjectName name)
Gets the ObjectInstance for a given MBean registered with the MBean server.

param
name The object name of the MBean.
return
The ObjectInstance associated to the MBean specified by name.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.


	return mbsInterceptor.getObjectInstance(cloneObjectName(name));
    
private voidinitialize()
Initializes this MBeanServer, registering the MBeanServerDelegate.

This method must be called once, before using the MBeanServer.

	if (instantiator == null) throw new 
	    IllegalStateException("instantiator must not be null.");
	
	// Registers the MBeanServer identification MBean
	try {
	    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
		public Object run() throws Exception {
		    mbsInterceptor.registerMBean(
                            mBeanServerDelegateObject,
                            MBeanServerDelegate.DELEGATE_NAME);
		    return null;
		}
	    });
	} catch (SecurityException e) {
	    if (isDebugOn()) {
		debug("new", "Unexpected security exception occurred: " + 
		      e);       
	    }
	    throw e;
	} catch (Exception e) {
	    if (isDebugOn()) {
		debug("new", "Unexpected exception occurred: " + 
		      e.getClass().getName());       
	    }
	    throw new
		IllegalStateException("Can't register delegate.");
	}


	/* Add my class loader to the repository
	   This can be null if my class loader is the bootstrap
	   class loader.  The ClassLoaderRepository knows how
	   to handle that case.  */
	ClassLoader myLoader = outerShell.getClass().getClassLoader();
	final ModifiableClassLoaderRepository loaders = 
	    instantiator.getClassLoaderRepository();
	if (loaders != null) {
	    loaders.addClassLoader(myLoader);

	    /* Add the system class loader, so that if the MBean server is
	       loaded by the bootstrap class loader we can still load
	       MBeans from the classpath using
	       createMBean(className, objectName).
	       
	       If this class (JmxMBeanServer) was not loaded by the
	       system class loader or a parent of it, then the caller
	       must have RuntimePermission("getClassLoader") for the
	       getSystemClassLoader() call to succeed.  If the caller
	       does not have that permission, any call to
	       Class.getClassLoader() will fail.  Since there are lots
	       of those in JMX, we better throw the exception now.

	       This permission question is irrelevant when JMX is part
	       of J2SE (as of 1.5). */
	    ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
	    if (systemLoader != myLoader)
		loaders.addClassLoader(systemLoader);
	}
    
public java.lang.Objectinstantiate(java.lang.String className)
Instantiates an object using the list of all class loaders registered in the MBean server (using its {@link javax.management.loading.ClassLoaderRepository Default Loader Repository}). The object's class should have a public constructor. It returns a reference to the newly created object. The newly created object is not registered in the MBean server.

param
className The class name of the object to be instantiated.
return
The newly instantiated object.
exception
ReflectionException Wraps the {@link java.lang.ClassNotFoundException} or the {@link java.lang.Exception} that occurred when trying to invoke the object's constructor.
exception
MBeanException The constructor of the object has thrown an exception.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null.

 

	/* Permission check */
	checkMBeanPermission(className, null, null, "instantiate");

	return instantiator.instantiate(className);
    
public java.lang.Objectinstantiate(java.lang.String className, javax.management.ObjectName loaderName)
Instantiates an object using the class Loader specified by its ObjectName. If the loader name is null, the ClassLoader that loaded the MBean Server will be used. The object's class should have a public constructor. It returns a reference to the newly created object. The newly created object is not registered in the MBean server.

param
className The class name of the MBean to be instantiated.
param
loaderName The object name of the class loader to be used.
return
The newly instantiated object.
exception
ReflectionException Wraps the {@link java.lang.ClassNotFoundException} or the {@link java.lang.Exception} that occurred when trying to invoke the object's constructor.
exception
MBeanException The constructor of the object has thrown an exception.
exception
InstanceNotFoundException The specified class loader is not registered in the MBaenServer.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null.

     
         
	/* Permission check */
	checkMBeanPermission(className, null, null, "instantiate");

	ClassLoader myLoader = outerShell.getClass().getClassLoader();
    	return instantiator.instantiate(className, loaderName, myLoader);
    
public java.lang.Objectinstantiate(java.lang.String className, java.lang.Object[] params, java.lang.String[] signature)
Instantiates an object using the list of all class loaders registered in the MBean server (using its {@link javax.management.loading.ClassLoaderRepository Default Loader Repository}). The object's class should have a public constructor. The call returns a reference to the newly created object. The newly created object is not registered in the MBean server.

param
className The class name of the object to be instantiated.
param
params An array containing the parameters of the constructor to be invoked.
param
signature An array containing the signature of the constructor to be invoked.
return
The newly instantiated object.
exception
ReflectionException Wraps the {@link java.lang.ClassNotFoundException} or the {@link java.lang.Exception} that occurred when trying to invoke the object's constructor.
exception
MBeanException The constructor of the object has thrown an exception.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null.

 

	/* Permission check */
	checkMBeanPermission(className, null, null, "instantiate");

	ClassLoader myLoader = outerShell.getClass().getClassLoader();
	return instantiator.instantiate(className, params, signature,
					myLoader);
    
public java.lang.Objectinstantiate(java.lang.String className, javax.management.ObjectName loaderName, java.lang.Object[] params, java.lang.String[] signature)
Instantiates an object. The class loader to be used is identified by its object name. If the object name of the loader is null, the ClassLoader that loaded the MBean server will be used. The object's class should have a public constructor. The call returns a reference to the newly created object. The newly created object is not registered in the MBean server.

param
className The class name of the object to be instantiated.
param
params An array containing the parameters of the constructor to be invoked.
param
signature An array containing the signature of the constructor to be invoked.
param
loaderName The object name of the class loader to be used.
return
The newly instantiated object.
exception
ReflectionException Wraps the {@link java.lang.ClassNotFoundException} or the {@link java.lang.Exception} that occurred when trying to invoke the object's constructor.
exception
MBeanException The constructor of the object has thrown an exception.
exception
InstanceNotFoundException The specified class loader is not registered in the MBean server.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The className passed in parameter is null.

 

	/* Permission check */
	checkMBeanPermission(className, null, null, "instantiate");

	ClassLoader myLoader = outerShell.getClass().getClassLoader();
	return instantiator.instantiate(className,loaderName,params,signature,
					myLoader);
    
public booleaninterceptorsEnabled()
Tell whether {@link MBeanServerInterceptor}s are enabled on this object.

return
true if {@link MBeanServerInterceptor}s are enabled.
see
#newMBeanServer(java.lang.String,javax.management.MBeanServer,javax.management.MBeanServerDelegate,boolean)

	return interceptorsEnabled;
    
public java.lang.Objectinvoke(javax.management.ObjectName name, java.lang.String operationName, java.lang.Object[] params, java.lang.String[] signature)
Invokes an operation on an MBean.

param
name The object name of the MBean on which the method is to be invoked.
param
operationName The name of the operation to be invoked.
param
params An array containing the parameters to be set when the operation is invoked
param
signature An array containing the signature of the operation. The class objects will be loaded using the same class loader as the one used for loading the MBean on which the operation was invoked.
return
The object returned by the operation, which represents the result ofinvoking the operation on the MBean specified.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.
exception
MBeanException Wraps an exception thrown by the MBean's invoked method.
exception
ReflectionException Wraps an {@link java.lang.Exception} thrown while trying to invoke the method.

 
        return mbsInterceptor.invoke(cloneObjectName(name), operationName,
				     params, signature);
    
private booleanisDebugOn()

        return Trace.isSelected(Trace.LEVEL_DEBUG, Trace.INFO_MBEANSERVER);
    
public booleanisInstanceOf(javax.management.ObjectName name, java.lang.String className)
Returns true if the MBean specified is an instance of the specified class, false otherwise.

param
name The ObjectName of the MBean.
param
className The name of the class.
return
true if the MBean specified is an instance of the specified class, false otherwise.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.


	return mbsInterceptor.isInstanceOf(cloneObjectName(name), className);
    
public booleanisRegistered(javax.management.ObjectName name)
Checks whether an MBean, identified by its object name, is already registered with the MBean server.

param
name The object name of the MBean to be checked.
return
True if the MBean is already registered in the MBean server, false otherwise.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The object name in parameter is null.


        return mbsInterceptor.isRegistered(name);
    
private booleanisTraceOn()

        return Trace.isSelected(Trace.LEVEL_TRACE, Trace.INFO_MBEANSERVER);
    
public static javax.management.MBeanServernewMBeanServer(java.lang.String defaultDomain, javax.management.MBeanServer outer, javax.management.MBeanServerDelegate delegate, boolean interceptors)
This method creates a new MBeanServer implementation object. When creating a new MBeanServer the {@link javax.management.MBeanServerBuilder} first calls newMBeanServerDelegate() in order to obtain a new {@link javax.management.MBeanServerDelegate} for the new MBeanServer. Then it calls newMBeanServer(defaultDomain,outer,delegate) passing the delegate that should be used by the MBeanServer implementation.

Note that the passed delegate might not be directly the MBeanServerDelegate that was returned by this implementation. It could be, for instance, a new object wrapping the previously returned delegate.

The outer parameter is a pointer to the MBeanServer that should be passed to the {@link javax.management.MBeanRegistration} interface when registering MBeans inside the MBeanServer. If outer is null, then the MBeanServer implementation is free to use its own this pointer when invoking the {@link javax.management.MBeanRegistration} interface.

This makes it possible for a MBeanServer implementation to wrap another MBeanServer implementation, in order to implement, e.g, security checks, or to prevent access to the actual MBeanServer implementation by returning a pointer to a wrapping object.

param
defaultDomain Default domain of the new MBeanServer.
param
outer A pointer to the MBeanServer object that must be passed to the MBeans when invoking their {@link javax.management.MBeanRegistration} interface.
param
delegate A pointer to the MBeanServerDelegate associated with the new MBeanServer. The new MBeanServer must register this MBean in its MBean repository.
param
interceptors If true, {@link MBeanServerInterceptor}s will be enabled (default is false). Note: this parameter is not taken into account by this implementation - the default value false is always used.
return
A new private implementation of an MBeanServer.
see
#interceptorsEnabled
see
javax.management.MBeanServerBuilder
see
com.sun.jmx.mbeanserver.JmxMBeanServerBuilder

        // This constructor happens to disregard the value of the interceptors
        // flag - that is, it always uses the default value - false.
        // This is admitedly a bug, but we chose not to fix it for now
        // since we would rather not have anybody depending on the Sun private
        // interceptor APIs - which is most probably going to be removed and 
        // replaced by a public (javax) feature in the future.
        //
	return new JmxMBeanServer(defaultDomain,outer,delegate,interceptors);
    
public static javax.management.MBeanServerDelegatenewMBeanServerDelegate()
This method creates a new MBeanServerDelegate for a new MBeanServer. When creating a new MBeanServer the {@link javax.management.MBeanServerBuilder} first calls this method in order to create a new MBeanServerDelegate.
Then it calls newMBeanServer(defaultDomain,outer,delegate,interceptors) passing the delegate that should be used by the MBeanServer implementation.

Note that the passed delegate might not be directly the MBeanServerDelegate that was returned by this method. It could be, for instance, a new object wrapping the previously returned object.

return
A new {@link javax.management.MBeanServerDelegate}.

	return new MBeanServerDelegateImpl();
    
public java.util.SetqueryMBeans(javax.management.ObjectName name, javax.management.QueryExp query)
Gets MBeans controlled by the MBean server. This method allows any of the following to be obtained: All MBeans, a set of MBeans specified by pattern matching on the ObjectName and/or a Query expression, a specific MBean. When the object name is null or no domain and key properties are specified, all objects are to be selected (and filtered if a query is specified). It returns the set of ObjectInstance objects (containing the ObjectName and the Java Class name) for the selected MBeans.

param
name The object name pattern identifying the MBeans to be retrieved. If null or or no domain and key properties are specified, all the MBeans registered will be retrieved.
param
query The query expression to be applied for selecting MBeans. If null no query expression will be applied for selecting MBeans.
return
A set containing the ObjectInstance objects for the selected MBeans. If no MBean satisfies the query an empty list is returned.

	
	return mbsInterceptor.queryMBeans(cloneObjectName(name), query);
    
public java.util.SetqueryNames(javax.management.ObjectName name, javax.management.QueryExp query)
Gets the names of MBeans controlled by the MBean server. This method enables any of the following to be obtained: The names of all MBeans, the names of a set of MBeans specified by pattern matching on the ObjectName and/or a Query expression, a specific MBean name (equivalent to testing whether an MBean is registered). When the object name is null or or no domain and key properties are specified, all objects are selected (and filtered if a query is specified). It returns the set of ObjectNames for the MBeans selected.

param
name The object name pattern identifying the MBeans to be retrieved. If null or no domain and key properties are specified, all the MBeans registered will be retrieved.
param
query The query expression to be applied for selecting MBeans. If null no query expression will be applied for selecting MBeans.
return
A set containing the ObjectNames for the MBeans selected. If no MBean satisfies the query, an empty list is returned.


        return mbsInterceptor.queryNames(cloneObjectName(name), query); 
    
public javax.management.ObjectInstanceregisterMBean(java.lang.Object object, javax.management.ObjectName name)
Registers a pre-existing object as an MBean with the MBean server. If the object name given is null, the MBean may automatically provide its own name by implementing the {@link javax.management.MBeanRegistration MBeanRegistration} interface. The call returns an ObjectInstance object representing the registered MBean.

param
object The MBean to be registered as an MBean.
param
name The object name of the MBean. May be null.
return
The ObjectInstance for the MBean that has been registered.
exception
InstanceAlreadyExistsException The MBean is already under the control of the MBean server.
exception
MBeanRegistrationException The preRegister() (MBeanRegistration interface) method of the MBean has thrown an exception. The MBean will not be registered.
exception
NotCompliantMBeanException This object is not a JMX compliant MBean
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The object passed in parameter is null or no object name is specified.

 
	
	return mbsInterceptor.registerMBean(object, cloneObjectName(name));
    
public voidremoveNotificationListener(javax.management.ObjectName name, javax.management.NotificationListener listener)

	
	mbsInterceptor.removeNotificationListener(cloneObjectName(name),
						  listener);
    
public voidremoveNotificationListener(javax.management.ObjectName name, javax.management.NotificationListener listener, javax.management.NotificationFilter filter, java.lang.Object handback)

	
	mbsInterceptor.removeNotificationListener(cloneObjectName(name),
						  listener, filter, handback);
    
public voidremoveNotificationListener(javax.management.ObjectName name, javax.management.ObjectName listener)


	mbsInterceptor.removeNotificationListener(cloneObjectName(name),
						  listener);
    
public voidremoveNotificationListener(javax.management.ObjectName name, javax.management.ObjectName listener, javax.management.NotificationFilter filter, java.lang.Object handback)


	mbsInterceptor.removeNotificationListener(cloneObjectName(name),
						  listener, filter, handback);
    
public voidsetAttribute(javax.management.ObjectName name, javax.management.Attribute attribute)
Sets the value of a specific attribute of a named MBean. The MBean is identified by its object name.

param
name The name of the MBean within which the attribute is to be set.
param
attribute The identification of the attribute to be set and the value it is to be set to.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.
exception
AttributeNotFoundException The attribute specified is not accessible in the MBean.
exception
InvalidAttributeValueException The value specified for the attribute is not valid.
exception
MBeanException Wraps an exception thrown by the MBean's setter.
exception
ReflectionException Wraps an {@link java.lang.Exception} thrown when trying to invoke the setter.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The object name in parameter is null or the attribute in parameter is null.

 
	
	mbsInterceptor.setAttribute(cloneObjectName(name),
				    cloneAttribute(attribute));
    
public javax.management.AttributeListsetAttributes(javax.management.ObjectName name, javax.management.AttributeList attributes)
Sets the values of several attributes of a named MBean. The MBean is identified by its object name.

param
name The object name of the MBean within which the attributes are to be set.
param
attributes A list of attributes: The identification of the attributes to be set and the values they are to be set to.
return
The list of attributes that were set, with their new values.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.
exception
ReflectionException An exception occurred when trying to invoke the getAttributes method of a Dynamic MBean.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The object name in parameter is null or attributes in parameter is null.

 
	
	return mbsInterceptor.setAttributes(cloneObjectName(name),
					    cloneAttributeList(attributes));
    
public synchronized voidsetMBeanServerInterceptor(com.sun.jmx.interceptor.MBeanServerInterceptor interceptor)
Set the MBeanServerInterceptor.

exception
UnsupportedOperationException if {@link MBeanServerInterceptor}s are not enabled on this object.
see
#interceptorsEnabled

	if (!interceptorsEnabled) throw new UnsupportedOperationException(
	               "MBeanServerInterceptors are disabled.");
	if (interceptor == null) throw new
	    IllegalArgumentException("MBeanServerInterceptor is null");
	mbsInterceptor = interceptor;
    
private voidtrace(java.lang.String clz, java.lang.String func, java.lang.String info)

        Trace.send(Trace.LEVEL_TRACE, Trace.INFO_MBEANSERVER, clz, func, info);
    
private voidtrace(java.lang.String func, java.lang.String info)

        trace(dbgTag, func, info);
    
public voidunregisterMBean(javax.management.ObjectName name)
De-registers an MBean from the MBean server. The MBean is identified by its object name. Once the method has been invoked, the MBean may no longer be accessed by its object name.

param
name The object name of the MBean to be de-registered.
exception
InstanceNotFoundException The MBean specified is not registered in the MBean server.
exception
MBeanRegistrationException The preDeregister() (MBeanRegistration interface) method of the MBean has thrown an exception.
exception
RuntimeOperationsException Wraps an {@link java.lang.IllegalArgumentException}: The object name in parameter is null or the MBean you are when trying to de-register is the {@link javax.management.MBeanServerDelegate MBeanServerDelegate} MBean.

	mbsInterceptor.unregisterMBean(cloneObjectName(name));