| /* |
| * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| 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); |
| } |
| } |
| } |