You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1523 lines
65 KiB
1523 lines
65 KiB
/*
|
|
* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package com.sun.jmx.mbeanserver;
|
|
|
|
import com.sun.jmx.interceptor.DefaultMBeanServerInterceptor;
|
|
import com.sun.jmx.interceptor.MBeanServerInterceptor;
|
|
import static com.sun.jmx.defaults.JmxProperties.MBEANSERVER_LOGGER;
|
|
|
|
import java.io.ObjectInputStream;
|
|
import java.security.AccessController;
|
|
import java.security.Permission;
|
|
import java.security.PrivilegedAction;
|
|
import java.security.PrivilegedExceptionAction;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.logging.Level;
|
|
|
|
import javax.management.Attribute;
|
|
import javax.management.AttributeList;
|
|
import javax.management.AttributeNotFoundException;
|
|
import javax.management.InstanceAlreadyExistsException;
|
|
import javax.management.InstanceNotFoundException;
|
|
import javax.management.IntrospectionException;
|
|
import javax.management.InvalidAttributeValueException;
|
|
import javax.management.ListenerNotFoundException;
|
|
import javax.management.MBeanException;
|
|
import javax.management.MBeanInfo;
|
|
import javax.management.MBeanPermission;
|
|
import javax.management.MBeanRegistrationException;
|
|
import javax.management.MBeanServer;
|
|
import javax.management.MBeanServerDelegate;
|
|
import javax.management.MBeanServerPermission;
|
|
import javax.management.NotCompliantMBeanException;
|
|
import javax.management.NotificationFilter;
|
|
import javax.management.NotificationListener;
|
|
import javax.management.ObjectInstance;
|
|
import javax.management.ObjectName;
|
|
import javax.management.OperationsException;
|
|
import javax.management.QueryExp;
|
|
import javax.management.ReflectionException;
|
|
import javax.management.RuntimeOperationsException;
|
|
import javax.management.loading.ClassLoaderRepository;
|
|
|
|
/**
|
|
* 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.
|
|
* <P>
|
|
* 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.
|
|
* <P>
|
|
* 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 <CODE>ObjectName</CODE> of the
|
|
* {@link javax.management.MBeanServerDelegate MBeanServerDelegate}.
|
|
* This <CODE>ObjectName</CODE> is:
|
|
* <BR>
|
|
* <CODE>JMImplementation:type=MBeanServerDelegate</CODE>.
|
|
*
|
|
* @since 1.5
|
|
*/
|
|
public final class JmxMBeanServer
|
|
implements SunJmxMBeanServer {
|
|
|
|
/** Control the default locking policy of the repository.
|
|
* By default, we will be using a fair locking policy.
|
|
**/
|
|
public static final boolean DEFAULT_FAIR_LOCK_POLICY = true;
|
|
|
|
private final MBeanInstantiator instantiator;
|
|
private final SecureClassLoaderRepository secureClr;
|
|
|
|
/** true if interceptors are enabled **/
|
|
private final boolean interceptorsEnabled;
|
|
|
|
private final MBeanServer outerShell;
|
|
|
|
private volatile MBeanServer mbsInterceptor = null;
|
|
|
|
/** The MBeanServerDelegate object representing the MBean Server */
|
|
private final MBeanServerDelegate mBeanServerDelegateObject;
|
|
|
|
/**
|
|
* <b>Package:</b> Creates an MBeanServer with the
|
|
* specified default domain name, outer interface, and delegate.
|
|
* <p>The default domain name is used as the domain part in the ObjectName
|
|
* of MBeans if no domain is specified by the user.
|
|
* <ul><b>Note:</b>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.
|
|
* <p>
|
|
* By default, interceptors are disabled. Use
|
|
* {@link #JmxMBeanServer(java.lang.String,javax.management.MBeanServer,javax.management.MBeanServerDelegate,boolean)} to enable them.
|
|
* </ul>
|
|
* @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.
|
|
*/
|
|
JmxMBeanServer(String domain, MBeanServer outer,
|
|
MBeanServerDelegate delegate) {
|
|
this(domain,outer,delegate,null,false);
|
|
}
|
|
|
|
/**
|
|
* <b>Package:</b> Creates an MBeanServer with the
|
|
* specified default domain name, outer interface, and delegate.
|
|
* <p>The default domain name is used as the domain part in the ObjectName
|
|
* of MBeans if no domain is specified by the user.
|
|
* <ul><b>Note:</b>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.
|
|
* </ul>
|
|
* @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 <code>true</code>,
|
|
* {@link MBeanServerInterceptor} will be enabled (default is
|
|
* <code>false</code>)
|
|
* Note: this parameter is not taken into account by this
|
|
* implementation - the default value <code>false</code> is
|
|
* always used.
|
|
* @exception IllegalArgumentException if the instantiator is null.
|
|
*/
|
|
JmxMBeanServer(String domain, MBeanServer outer,
|
|
MBeanServerDelegate delegate, boolean interceptors) {
|
|
this(domain,outer,delegate,null,false);
|
|
}
|
|
|
|
/**
|
|
* <b>Package:</b> 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 <code>true</code>,
|
|
* {@link MBeanServerInterceptor} will be enabled (default is
|
|
* <code>false</code>).
|
|
*/
|
|
JmxMBeanServer(String domain, MBeanServer outer,
|
|
MBeanServerDelegate delegate,
|
|
MBeanInstantiator instantiator,
|
|
boolean interceptors) {
|
|
this(domain,outer,delegate,instantiator,interceptors,true);
|
|
}
|
|
|
|
/**
|
|
* <b>Package:</b> 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 <code>true</code>,
|
|
* {@link MBeanServerInterceptor} will be enabled (default is
|
|
* <code>false</code>).
|
|
* @param fairLock If {@code true}, the MBean repository will use a {@link
|
|
* java.util.concurrent.locks.ReentrantReadWriteLock#ReentrantReadWriteLock(boolean)
|
|
* fair locking} policy.
|
|
*/
|
|
JmxMBeanServer(String domain, MBeanServer outer,
|
|
MBeanServerDelegate delegate,
|
|
MBeanInstantiator instantiator,
|
|
boolean interceptors,
|
|
boolean fairLock) {
|
|
|
|
if (instantiator == null) {
|
|
final ModifiableClassLoaderRepository
|
|
clr = new ClassLoaderRepositorySupport();
|
|
instantiator = new MBeanInstantiator(clr);
|
|
}
|
|
|
|
final MBeanInstantiator fInstantiator = instantiator;
|
|
this.secureClr = new
|
|
SecureClassLoaderRepository(AccessController.doPrivileged(new PrivilegedAction<ClassLoaderRepository>() {
|
|
@Override
|
|
public ClassLoaderRepository run() {
|
|
return fInstantiator.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();
|
|
}
|
|
|
|
/**
|
|
* Tell whether {@link MBeanServerInterceptor}s are enabled on this
|
|
* object.
|
|
* @return <code>true</code> if {@link MBeanServerInterceptor}s are
|
|
* enabled.
|
|
* @see #newMBeanServer(java.lang.String,javax.management.MBeanServer,javax.management.MBeanServerDelegate,boolean)
|
|
**/
|
|
public boolean interceptorsEnabled() {
|
|
return interceptorsEnabled;
|
|
}
|
|
|
|
/**
|
|
* Return the MBeanInstantiator associated to this MBeanServer.
|
|
* @exception UnsupportedOperationException if
|
|
* {@link MBeanServerInterceptor}s
|
|
* are not enabled on this object.
|
|
* @see #interceptorsEnabled
|
|
**/
|
|
public MBeanInstantiator getMBeanInstantiator() {
|
|
if (interceptorsEnabled) return instantiator;
|
|
else throw new UnsupportedOperationException(
|
|
"MBeanServerInterceptors are disabled.");
|
|
}
|
|
|
|
/**
|
|
* 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 <CODE>ObjectInstance</CODE> 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 <CODE>ObjectInstance</CODE>, containing the
|
|
* <CODE>ObjectName</CODE> and the Java class name of the newly
|
|
* instantiated MBean.
|
|
*
|
|
* @exception ReflectionException Wraps an
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or an
|
|
* <CODE>{@link java.lang.Exception}</CODE> 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 <CODE>preRegister()</CODE>
|
|
* (<CODE>MBeanRegistration</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>:
|
|
* The className passed in parameter is null, the
|
|
* <CODE>ObjectName</CODE> passed in parameter contains a pattern
|
|
* or no <CODE>ObjectName</CODE> is specified for the MBean.
|
|
*
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name)
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException {
|
|
|
|
return mbsInterceptor.createMBean(className,
|
|
cloneObjectName(name),
|
|
(Object[]) null,
|
|
(String[]) null);
|
|
}
|
|
|
|
/**
|
|
* 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 <CODE>ObjectInstance</CODE> 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 <CODE>ObjectInstance</CODE>, containing the
|
|
* <CODE>ObjectName</CODE> and the Java class name
|
|
* of the newly instantiated MBean.
|
|
*
|
|
* @exception ReflectionException Wraps an
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or an
|
|
* <CODE>{@link java.lang.Exception}</CODE> 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 <CODE>preRegister()</CODE>
|
|
* (<CODE>MBeanRegistration</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The
|
|
* className passed in parameter is null, the <CODE>ObjectName</CODE>
|
|
* passed in parameter contains a pattern or no
|
|
* <CODE>ObjectName</CODE> is specified for the MBean.
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
ObjectName loaderName)
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException, InstanceNotFoundException {
|
|
|
|
return mbsInterceptor.createMBean(className,
|
|
cloneObjectName(name),
|
|
loaderName,
|
|
(Object[]) null,
|
|
(String[]) null);
|
|
}
|
|
|
|
/**
|
|
* 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 <CODE>ObjectInstance</CODE> 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 <CODE>ObjectInstance</CODE>, containing the
|
|
* <CODE>ObjectName</CODE> and the Java class name
|
|
* of the newly instantiated MBean.
|
|
*
|
|
* @exception ReflectionException Wraps a
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or an
|
|
* <CODE>{@link java.lang.Exception}</CODE> 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 <CODE>preRegister()</CODE>
|
|
* (<CODE>MBeanRegistration</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The
|
|
* className passed in parameter is null, the <CODE>ObjectName</CODE>
|
|
* passed in parameter contains a pattern or no
|
|
* <CODE>ObjectName</CODE> is specified for the MBean.
|
|
*
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
Object params[], String signature[])
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException {
|
|
|
|
return mbsInterceptor.createMBean(className, cloneObjectName(name),
|
|
params, 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 <CODE>ObjectInstance</CODE> 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 <CODE>ObjectInstance</CODE>, containing the
|
|
* <CODE>ObjectName</CODE> and the Java class name of the newly
|
|
* instantiated MBean.
|
|
*
|
|
* @exception ReflectionException Wraps a
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or an
|
|
* <CODE>{@link java.lang.Exception}</CODE>
|
|
* 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 <CODE>preRegister()</CODE>
|
|
* (<CODE>MBeanRegistration</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The
|
|
* className passed in parameter is null, the <CODE>ObjectName</CODE>
|
|
* passed in parameter contains a pattern or no
|
|
* <CODE>ObjectName</CODE> is specified for the MBean.
|
|
*
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
ObjectName loaderName, Object params[],
|
|
String signature[])
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException, InstanceNotFoundException {
|
|
|
|
return mbsInterceptor.createMBean(className, cloneObjectName(name),
|
|
loaderName, params, signature);
|
|
}
|
|
|
|
/**
|
|
* 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 <CODE>ObjectInstance</CODE> 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 <CODE>ObjectInstance</CODE> for the MBean that has been
|
|
* registered.
|
|
*
|
|
* @exception InstanceAlreadyExistsException The MBean is already
|
|
* under the control of the MBean server.
|
|
* @exception MBeanRegistrationException The <CODE>preRegister()</CODE>
|
|
* (<CODE>MBeanRegistration</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The
|
|
* object passed in parameter is null or no object name is specified.
|
|
*
|
|
*/
|
|
public ObjectInstance registerMBean(Object object, ObjectName name)
|
|
throws InstanceAlreadyExistsException, MBeanRegistrationException,
|
|
NotCompliantMBeanException {
|
|
|
|
return mbsInterceptor.registerMBean(object, cloneObjectName(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 <code>preDeregister()</code>
|
|
* (<CODE>MBeanRegistration</CODE> interface) method of the MBean
|
|
* has thrown an exception.
|
|
* @exception RuntimeOperationsException Wraps an
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: 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.
|
|
**/
|
|
public void unregisterMBean(ObjectName name)
|
|
throws InstanceNotFoundException, MBeanRegistrationException {
|
|
mbsInterceptor.unregisterMBean(cloneObjectName(name));
|
|
}
|
|
|
|
/**
|
|
* Gets the <CODE>ObjectInstance</CODE> for a given MBean registered
|
|
* with the MBean server.
|
|
*
|
|
* @param name The object name of the MBean.
|
|
*
|
|
* @return The <CODE>ObjectInstance</CODE> associated to the MBean
|
|
* specified by <VAR>name</VAR>.
|
|
*
|
|
* @exception InstanceNotFoundException The MBean specified is not
|
|
* registered in the MBean server.
|
|
*/
|
|
public ObjectInstance getObjectInstance(ObjectName name)
|
|
throws InstanceNotFoundException {
|
|
|
|
return mbsInterceptor.getObjectInstance(cloneObjectName(name));
|
|
}
|
|
|
|
/**
|
|
* 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 <CODE>ObjectName</CODE> 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 <CODE>ObjectInstance</CODE> objects (containing the
|
|
* <CODE>ObjectName</CODE> 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 <CODE>ObjectInstance</CODE> objects
|
|
* for the selected MBeans.
|
|
* If no MBean satisfies the query an empty list is returned.
|
|
*
|
|
*/
|
|
public Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query) {
|
|
|
|
return mbsInterceptor.queryMBeans(cloneObjectName(name), 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
|
|
* <CODE>ObjectName</CODE> 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.
|
|
*
|
|
*/
|
|
public Set<ObjectName> queryNames(ObjectName name, QueryExp query) {
|
|
|
|
return mbsInterceptor.queryNames(cloneObjectName(name), query);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The object
|
|
* name in parameter is null.
|
|
*
|
|
*/
|
|
public boolean isRegistered(ObjectName name) {
|
|
|
|
return mbsInterceptor.isRegistered(name);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of MBeans registered in the MBean server.
|
|
*/
|
|
public Integer getMBeanCount() {
|
|
|
|
return mbsInterceptor.getMBeanCount();
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.Exception}</CODE> thrown when trying to
|
|
* invoke the setter.
|
|
* @exception RuntimeOperationsException Wraps an
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>:
|
|
* The object name in parameter is null or the attribute in
|
|
* parameter is null.
|
|
*/
|
|
public Object getAttribute(ObjectName name, String attribute)
|
|
throws MBeanException, AttributeNotFoundException,
|
|
InstanceNotFoundException, ReflectionException {
|
|
|
|
return mbsInterceptor.getAttribute(cloneObjectName(name), attribute);
|
|
}
|
|
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The
|
|
* object name in parameter is null or attributes in parameter
|
|
* is null.
|
|
*
|
|
*/
|
|
public AttributeList getAttributes(ObjectName name, String[] attributes)
|
|
throws InstanceNotFoundException, ReflectionException {
|
|
|
|
return mbsInterceptor.getAttributes(cloneObjectName(name), attributes);
|
|
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.Exception}</CODE> thrown when trying
|
|
* to invoke the setter.
|
|
* @exception RuntimeOperationsException Wraps an
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The
|
|
* object name in parameter is null or the attribute in parameter
|
|
* is null.
|
|
*/
|
|
public void setAttribute(ObjectName name, Attribute attribute)
|
|
throws InstanceNotFoundException, AttributeNotFoundException,
|
|
InvalidAttributeValueException, MBeanException,
|
|
ReflectionException {
|
|
|
|
mbsInterceptor.setAttribute(cloneObjectName(name),
|
|
cloneAttribute(attribute));
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>:
|
|
* The object name in parameter is null or attributes in
|
|
* parameter is null.
|
|
*
|
|
*/
|
|
public AttributeList setAttributes(ObjectName name,
|
|
AttributeList attributes)
|
|
throws InstanceNotFoundException, ReflectionException {
|
|
|
|
return mbsInterceptor.setAttributes(cloneObjectName(name),
|
|
cloneAttributeList(attributes));
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.Exception}</CODE> thrown while trying
|
|
* to invoke the method.
|
|
*
|
|
*/
|
|
public Object invoke(ObjectName name, String operationName,
|
|
Object params[], String signature[])
|
|
throws InstanceNotFoundException, MBeanException,
|
|
ReflectionException {
|
|
return mbsInterceptor.invoke(cloneObjectName(name), operationName,
|
|
params, signature);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
public String getDefaultDomain() {
|
|
return mbsInterceptor.getDefaultDomain();
|
|
}
|
|
|
|
// From MBeanServer
|
|
public String[] getDomains() {
|
|
return mbsInterceptor.getDomains();
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
public void addNotificationListener(ObjectName name,
|
|
NotificationListener listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws InstanceNotFoundException {
|
|
|
|
mbsInterceptor.addNotificationListener(cloneObjectName(name), listener,
|
|
filter, 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.
|
|
*/
|
|
public void addNotificationListener(ObjectName name, ObjectName listener,
|
|
NotificationFilter filter, Object handback)
|
|
throws InstanceNotFoundException {
|
|
|
|
mbsInterceptor.addNotificationListener(cloneObjectName(name), listener,
|
|
filter, handback);
|
|
}
|
|
|
|
public void removeNotificationListener(ObjectName name,
|
|
NotificationListener listener)
|
|
throws InstanceNotFoundException, ListenerNotFoundException {
|
|
|
|
mbsInterceptor.removeNotificationListener(cloneObjectName(name),
|
|
listener);
|
|
}
|
|
|
|
public void removeNotificationListener(ObjectName name,
|
|
NotificationListener listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws InstanceNotFoundException, ListenerNotFoundException {
|
|
|
|
mbsInterceptor.removeNotificationListener(cloneObjectName(name),
|
|
listener, filter, handback);
|
|
}
|
|
|
|
public void removeNotificationListener(ObjectName name,
|
|
ObjectName listener)
|
|
throws InstanceNotFoundException, ListenerNotFoundException {
|
|
|
|
mbsInterceptor.removeNotificationListener(cloneObjectName(name),
|
|
listener);
|
|
}
|
|
|
|
public void removeNotificationListener(ObjectName name,
|
|
ObjectName listener,
|
|
NotificationFilter filter,
|
|
Object handback)
|
|
throws InstanceNotFoundException, ListenerNotFoundException {
|
|
|
|
mbsInterceptor.removeNotificationListener(cloneObjectName(name),
|
|
listener, filter, handback);
|
|
}
|
|
|
|
/**
|
|
* 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 <CODE>MBeanInfo</CODE> 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.
|
|
*/
|
|
public MBeanInfo getMBeanInfo(ObjectName name) throws
|
|
InstanceNotFoundException, IntrospectionException, ReflectionException {
|
|
|
|
return mbsInterceptor.getMBeanInfo(cloneObjectName(name));
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or the
|
|
* <CODE>{@link java.lang.Exception}</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>:
|
|
* The className passed in parameter is null.
|
|
*
|
|
*/
|
|
public Object instantiate(String className)
|
|
throws ReflectionException, MBeanException {
|
|
|
|
/* Permission check */
|
|
checkMBeanPermission(className, null, null, "instantiate");
|
|
|
|
return instantiator.instantiate(className);
|
|
}
|
|
|
|
/**
|
|
* Instantiates an object using the class Loader specified by its
|
|
* <CODE>ObjectName</CODE>.
|
|
* 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
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or the
|
|
* <CODE>{@link java.lang.Exception}</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>: The
|
|
* className passed in parameter is null.
|
|
*
|
|
*/
|
|
public Object instantiate(String className, ObjectName loaderName)
|
|
throws ReflectionException, MBeanException,
|
|
InstanceNotFoundException {
|
|
|
|
/* Permission check */
|
|
checkMBeanPermission(className, null, null, "instantiate");
|
|
|
|
ClassLoader myLoader = outerShell.getClass().getClassLoader();
|
|
return instantiator.instantiate(className, loaderName, myLoader);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or the
|
|
* <CODE>{@link java.lang.Exception}</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>:
|
|
* The className passed in parameter is null.
|
|
*
|
|
*/
|
|
public Object instantiate(String className, Object params[],
|
|
String signature[])
|
|
throws ReflectionException, MBeanException {
|
|
|
|
/* Permission check */
|
|
checkMBeanPermission(className, null, null, "instantiate");
|
|
|
|
ClassLoader myLoader = outerShell.getClass().getClassLoader();
|
|
return instantiator.instantiate(className, params, signature,
|
|
myLoader);
|
|
}
|
|
|
|
/**
|
|
* 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
|
|
* <CODE>{@link java.lang.ClassNotFoundException}</CODE> or the
|
|
* <CODE>{@link java.lang.Exception}</CODE> 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
|
|
* <CODE>{@link java.lang.IllegalArgumentException}</CODE>:
|
|
* The className passed in parameter is null.
|
|
*
|
|
*/
|
|
public Object instantiate(String className, ObjectName loaderName,
|
|
Object params[], String signature[])
|
|
throws ReflectionException, MBeanException,
|
|
InstanceNotFoundException {
|
|
|
|
/* Permission check */
|
|
checkMBeanPermission(className, null, null, "instantiate");
|
|
|
|
ClassLoader myLoader = outerShell.getClass().getClassLoader();
|
|
return instantiator.instantiate(className,loaderName,params,signature,
|
|
myLoader);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the MBean specified is an instance of the specified
|
|
* class, false otherwise.
|
|
*
|
|
* @param name The <CODE>ObjectName</CODE> 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.
|
|
*/
|
|
public boolean isInstanceOf(ObjectName name, String className)
|
|
throws InstanceNotFoundException {
|
|
|
|
return mbsInterceptor.isInstanceOf(cloneObjectName(name), className);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
*/
|
|
@Deprecated
|
|
public ObjectInputStream deserialize(ObjectName name, byte[] data)
|
|
throws InstanceNotFoundException, OperationsException {
|
|
|
|
/* Permission check */
|
|
// This call requires MBeanPermission 'getClassLoaderFor'
|
|
final ClassLoader loader = getClassLoaderFor(name);
|
|
|
|
return instantiator.deserialize(loader, 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
|
|
*
|
|
*/
|
|
@Deprecated
|
|
public ObjectInputStream deserialize(String className, byte[] data)
|
|
throws OperationsException, ReflectionException {
|
|
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
*/
|
|
@Deprecated
|
|
public ObjectInputStream deserialize(String className,
|
|
ObjectName loaderName,
|
|
byte[] data) throws
|
|
InstanceNotFoundException, OperationsException, ReflectionException {
|
|
|
|
// 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);
|
|
}
|
|
|
|
/**
|
|
* Initializes this MBeanServer, registering the MBeanServerDelegate.
|
|
* <p>This method must be called once, before using the MBeanServer.
|
|
**/
|
|
private void initialize() {
|
|
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 (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
|
|
MBEANSERVER_LOGGER.logp(Level.FINEST,
|
|
JmxMBeanServer.class.getName(), "initialize",
|
|
"Unexpected security exception occurred", e);
|
|
}
|
|
throw e;
|
|
} catch (Exception e) {
|
|
if (MBEANSERVER_LOGGER.isLoggable(Level.FINEST)) {
|
|
MBEANSERVER_LOGGER.logp(Level.FINEST,
|
|
JmxMBeanServer.class.getName(), "initialize",
|
|
"Unexpected exception occurred", e);
|
|
}
|
|
throw new
|
|
IllegalStateException("Can't register delegate.",e);
|
|
}
|
|
|
|
|
|
/* 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 = AccessController.doPrivileged(new PrivilegedAction<ModifiableClassLoaderRepository>() {
|
|
|
|
@Override
|
|
public ModifiableClassLoaderRepository run() {
|
|
return 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);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return the MBeanServerInterceptor.
|
|
* @exception UnsupportedOperationException if
|
|
* {@link MBeanServerInterceptor}s
|
|
* are not enabled on this object.
|
|
* @see #interceptorsEnabled
|
|
**/
|
|
public synchronized MBeanServer getMBeanServerInterceptor() {
|
|
if (interceptorsEnabled) return mbsInterceptor;
|
|
else throw new UnsupportedOperationException(
|
|
"MBeanServerInterceptors are disabled.");
|
|
}
|
|
|
|
/**
|
|
* Set the MBeanServerInterceptor.
|
|
* @exception UnsupportedOperationException if
|
|
* {@link MBeanServerInterceptor}s
|
|
* are not enabled on this object.
|
|
* @see #interceptorsEnabled
|
|
**/
|
|
public synchronized void
|
|
setMBeanServerInterceptor(MBeanServer interceptor) {
|
|
if (!interceptorsEnabled) throw new UnsupportedOperationException(
|
|
"MBeanServerInterceptors are disabled.");
|
|
if (interceptor == null) throw new
|
|
IllegalArgumentException("MBeanServerInterceptor is null");
|
|
mbsInterceptor = interceptor;
|
|
}
|
|
|
|
/**
|
|
* <p>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.
|
|
*/
|
|
public ClassLoader getClassLoaderFor(ObjectName mbeanName)
|
|
throws InstanceNotFoundException {
|
|
return mbsInterceptor.getClassLoaderFor(cloneObjectName(mbeanName));
|
|
}
|
|
|
|
/**
|
|
* <p>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.
|
|
*/
|
|
public ClassLoader getClassLoader(ObjectName loaderName)
|
|
throws InstanceNotFoundException {
|
|
return mbsInterceptor.getClassLoader(cloneObjectName(loaderName));
|
|
}
|
|
|
|
/**
|
|
* <p>Return the ClassLoaderRepository for that MBeanServer.
|
|
* @return The ClassLoaderRepository for that MBeanServer.
|
|
**/
|
|
public ClassLoaderRepository getClassLoaderRepository() {
|
|
/* Permission check */
|
|
checkMBeanPermission(null, null, null, "getClassLoaderRepository");
|
|
return secureClr;
|
|
}
|
|
|
|
public MBeanServerDelegate getMBeanServerDelegate() {
|
|
if (!interceptorsEnabled) throw new UnsupportedOperationException(
|
|
"MBeanServerInterceptors are disabled.");
|
|
return mBeanServerDelegateObject;
|
|
}
|
|
|
|
// These methods are called by the JMX MBeanServerBuilder.
|
|
|
|
/**
|
|
* 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.
|
|
* <br>Then it calls
|
|
* <code>newMBeanServer(defaultDomain,outer,delegate,interceptors)</code>
|
|
* passing the <var>delegate</var> that should be used by the MBeanServer
|
|
* implementation.
|
|
* <p>Note that the passed <var>delegate</var> 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}.
|
|
**/
|
|
public static MBeanServerDelegate newMBeanServerDelegate() {
|
|
return new MBeanServerDelegateImpl();
|
|
}
|
|
|
|
/**
|
|
* This method creates a new MBeanServer implementation object.
|
|
* When creating a new MBeanServer the
|
|
* {@link javax.management.MBeanServerBuilder} first calls
|
|
* <code>newMBeanServerDelegate()</code> in order to obtain a new
|
|
* {@link javax.management.MBeanServerDelegate} for the new
|
|
* MBeanServer. Then it calls
|
|
* <code>newMBeanServer(defaultDomain,outer,delegate)</code>
|
|
* passing the <var>delegate</var> that should be used by the
|
|
* MBeanServer implementation.
|
|
* <p>Note that the passed <var>delegate</var> 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.
|
|
* <p>The <var>outer</var> 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 <var>outer</var> is <code>null</code>, then the MBeanServer
|
|
* implementation is free to use its own <code>this</code> pointer when
|
|
* invoking the {@link javax.management.MBeanRegistration} interface.
|
|
* <p>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 <code>true</code>,
|
|
* {@link MBeanServerInterceptor}s will be enabled (default is
|
|
* <code>false</code>).
|
|
* Note: this parameter is not taken into account by this
|
|
* implementation - the default value <code>false</code> is
|
|
* always used.
|
|
* @return A new private implementation of an MBeanServer.
|
|
* @see #interceptorsEnabled
|
|
* @see javax.management.MBeanServerBuilder
|
|
* @see com.sun.jmx.mbeanserver.JmxMBeanServerBuilder
|
|
**/
|
|
public static MBeanServer newMBeanServer(String defaultDomain,
|
|
MBeanServer outer,
|
|
MBeanServerDelegate delegate,
|
|
boolean interceptors) {
|
|
// Determine whether to use fair locking for the repository.
|
|
// Default is true.
|
|
final boolean fairLock = DEFAULT_FAIR_LOCK_POLICY;
|
|
|
|
checkNewMBeanServerPermission();
|
|
|
|
// 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,null,
|
|
interceptors,fairLock);
|
|
}
|
|
|
|
// JMX OBJECT CLONING
|
|
//-------------------
|
|
|
|
/**
|
|
* Clone object name.
|
|
*/
|
|
private ObjectName cloneObjectName(ObjectName name) {
|
|
if (name != null) {
|
|
return ObjectName.getInstance(name);
|
|
}
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* Clone attribute.
|
|
*/
|
|
private Attribute cloneAttribute(Attribute attribute) {
|
|
if (attribute != null) {
|
|
if (!attribute.getClass().equals(Attribute.class)) {
|
|
return new Attribute(attribute.getName(), attribute.getValue());
|
|
}
|
|
}
|
|
return attribute;
|
|
}
|
|
|
|
/**
|
|
* Clone attribute list.
|
|
*/
|
|
private AttributeList cloneAttributeList(AttributeList list) {
|
|
if (list != null) {
|
|
List<Attribute> alist = list.asList();
|
|
if (!list.getClass().equals(AttributeList.class)) {
|
|
// Create new attribute list
|
|
//
|
|
AttributeList newList = new AttributeList(alist.size());
|
|
|
|
// Iterate through list and replace non JMX attributes
|
|
//
|
|
for (Attribute attribute : alist)
|
|
newList.add(cloneAttribute(attribute));
|
|
return newList;
|
|
} else {
|
|
// Iterate through list and replace non JMX attributes
|
|
//
|
|
for (int i = 0; i < alist.size(); i++) {
|
|
Attribute attribute = alist.get(i);
|
|
if (!attribute.getClass().equals(Attribute.class)) {
|
|
list.set(i, cloneAttribute(attribute));
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
// SECURITY CHECKS
|
|
//----------------
|
|
|
|
private static void checkMBeanPermission(String classname,
|
|
String member,
|
|
ObjectName objectName,
|
|
String actions)
|
|
throws SecurityException {
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null) {
|
|
Permission perm = new MBeanPermission(classname,
|
|
member,
|
|
objectName,
|
|
actions);
|
|
sm.checkPermission(perm);
|
|
}
|
|
}
|
|
|
|
private static void checkNewMBeanServerPermission() {
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null) {
|
|
Permission perm = new MBeanServerPermission("newMBeanServer");
|
|
sm.checkPermission(perm);
|
|
}
|
|
}
|
|
}
|