/*
* 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);
}
}
}