jdk-sandbox: comparison jdk/src/share/classes/com/sun/jmx/interceptor/DefaultMBeanServerInterceptor.java

equal deleted inserted replaced

-:460e37d40f12
+:acaa49a2768a
 // JMX RI
 import static com.sun.jmx.defaults.JmxProperties.MBEANSERVER_LOGGER;
 import com.sun.jmx.mbeanserver.DynamicMBean2;
 import com.sun.jmx.mbeanserver.Introspector;
-import com.sun.jmx.mbeanserver.MBeanInjector;
 import com.sun.jmx.mbeanserver.MBeanInstantiator;
 import com.sun.jmx.mbeanserver.ModifiableClassLoaderRepository;
 import com.sun.jmx.mbeanserver.NamedObject;
-import com.sun.jmx.mbeanserver.NotifySupport;
 import com.sun.jmx.mbeanserver.Repository;
 import com.sun.jmx.mbeanserver.Repository.RegistrationContext;
 import com.sun.jmx.mbeanserver.Util;
 import com.sun.jmx.remote.util.EnvHelp;
+import java.io.ObjectInputStream;
 import java.lang.ref.WeakReference;
 import java.security.AccessControlContext;
 import java.security.AccessController;
 import java.security.Permission;
 import java.security.PrivilegedAction;
 import java.security.ProtectionDomain;
 import java.util.ArrayList;
 import java.util.HashSet;
-import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
-import java.util.Queue;
 import java.util.Set;
 import java.util.WeakHashMap;
 import java.util.logging.Level;
 // JMX import
 import javax.management.Attribute;
 import javax.management.AttributeList;
 import javax.management.AttributeNotFoundException;
 import javax.management.DynamicMBean;
-import javax.management.DynamicWrapperMBean;
 import javax.management.InstanceAlreadyExistsException;
 import javax.management.InstanceNotFoundException;
 import javax.management.IntrospectionException;
 import javax.management.InvalidAttributeValueException;
 import javax.management.JMRuntimeException;
 import javax.management.ListenerNotFoundException;
 import javax.management.MBeanException;
 import javax.management.MBeanInfo;
-import javax.management.MBeanNotificationInfo;
 import javax.management.MBeanPermission;
 import javax.management.MBeanRegistration;
 import javax.management.MBeanRegistrationException;
 import javax.management.MBeanServer;
 import javax.management.MBeanServerDelegate;
 import javax.management.MBeanServerNotification;
 import javax.management.MBeanTrustPermission;
 import javax.management.NotCompliantMBeanException;
 import javax.management.Notification;
 import javax.management.NotificationBroadcaster;
-import javax.management.NotificationBroadcasterSupport;
 import javax.management.NotificationEmitter;
 import javax.management.NotificationFilter;
 import javax.management.NotificationListener;
 import javax.management.ObjectInstance;
 import javax.management.ObjectName;
+import javax.management.OperationsException;
 import javax.management.QueryEval;
 import javax.management.QueryExp;
 import javax.management.ReflectionException;
 import javax.management.RuntimeErrorException;
 import javax.management.RuntimeMBeanException;
 import javax.management.RuntimeOperationsException;
-import javax.management.namespace.JMXNamespace;
+import javax.management.loading.ClassLoaderRepository;
 /**
 * This is the default 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.
 * <BR>
 * <CODE>JMImplementation:type=MBeanServerDelegate</CODE>.
 *
 * @since 1.5
 */
-public class DefaultMBeanServerInterceptor
+public class DefaultMBeanServerInterceptor implements MBeanServerInterceptor {
-extends MBeanServerInterceptorSupport {
 /** The MBeanInstantiator object used by the
 *  DefaultMBeanServerInterceptor */
 private final transient MBeanInstantiator instantiator;
 WeakHashMap<ListenerWrapper, WeakReference<ListenerWrapper>>
 listenerWrappers =
 new WeakHashMap<ListenerWrapper,
 WeakReference<ListenerWrapper>>();
-private final NamespaceDispatchInterceptor dispatcher;
 /** The default domain of the object names */
 private final String domain;
-/** The mbeanServerName  */
-private final String mbeanServerName;
 /** The sequence number identifying the notifications sent */
 // Now sequence number is handled by MBeanServerDelegate.
 // private int sequenceNumber=0;
 *        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 repository The repository to use for this MBeanServer.
-* @param dispatcher The dispatcher used by this MBeanServer
 */
 public DefaultMBeanServerInterceptor(MBeanServer         outer,
 MBeanServerDelegate delegate,
 MBeanInstantiator   instantiator,
-Repository          repository,
+Repository          repository) {
-NamespaceDispatchInterceptor dispatcher)  {
 if (outer == null) throw new
 IllegalArgumentException("outer MBeanServer cannot be null");
 if (delegate == null) throw new
 IllegalArgumentException("MBeanServerDelegate cannot be null");
 if (instantiator == null) throw new
 this.server   = outer;
 this.delegate = delegate;
 this.instantiator = instantiator;
 this.repository   = repository;
 this.domain       = repository.getDefaultDomain();
-this.dispatcher   = dispatcher;
-this.mbeanServerName = Util.getMBeanServerSecurityName(delegate);
 }
 public ObjectInstance createMBean(String className, ObjectName name)
 throws ReflectionException, InstanceAlreadyExistsException,
 MBeanRegistrationException, MBeanException,
 }
 name = nonDefaultDomain(name);
 }
-checkMBeanPermission(mbeanServerName,className, null, null, "instantiate");
+checkMBeanPermission(className, null, null, "instantiate");
-checkMBeanPermission(mbeanServerName,className, null, name, "registerMBean");
+checkMBeanPermission(className, null, name, "registerMBean");
 /* Load the appropriate class. */
 if (withDefaultLoaderRepository) {
 if (MBEANSERVER_LOGGER.isLoggable(Level.FINER)) {
 MBEANSERVER_LOGGER.logp(Level.FINER,
 Introspector.checkCompliance(theClass);
 final String infoClassName = getNewMBeanClassName(object);
-checkMBeanPermission(mbeanServerName,infoClassName, null, name, "registerMBean");
+checkMBeanPermission(infoClassName, null, name, "registerMBean");
 checkMBeanTrustPermission(theClass);
 return registerObject(infoClassName, object, name);
 }
 throws InstanceNotFoundException, MBeanRegistrationException {
 DynamicMBean instance = getMBean(name);
 // may throw InstanceNotFoundException
-checkMBeanPermission(mbeanServerName, instance, null, name,
+checkMBeanPermission(instance, null, name, "unregisterMBean");
-"unregisterMBean");
 if (instance instanceof MBeanRegistration)
 preDeregisterInvoke((MBeanRegistration) instance);
 final Object resource = getResource(instance);
 throws InstanceNotFoundException {
 name = nonDefaultDomain(name);
 DynamicMBean instance = getMBean(name);
-checkMBeanPermission(mbeanServerName,
+checkMBeanPermission(instance, null, name, "getObjectInstance");
-instance, null, name, "getObjectInstance");
 final String className = getClassName(instance);
 return new ObjectInstance(name, className);
 }
 public Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query) {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 // Check if the caller has the right to invoke 'queryMBeans'
 //
-checkMBeanPermission(mbeanServerName,(String) null, null, null, "queryMBeans");
+checkMBeanPermission((String) null, null, null, "queryMBeans");
 // Perform query without "query".
 //
 Set<ObjectInstance> list = queryMBeansImpl(name, null);
 //
 Set<ObjectInstance> allowedList =
 new HashSet<ObjectInstance>(list.size());
 for (ObjectInstance oi : list) {
 try {
-checkMBeanPermission(mbeanServerName,oi.getClassName(), null,
+checkMBeanPermission(oi.getClassName(), null,
 oi.getObjectName(), "queryMBeans");
 allowedList.add(oi);
 } catch (SecurityException e) {
 // OK: Do not add this ObjectInstance to the list
 }
 Set<ObjectName> queryList;
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 // Check if the caller has the right to invoke 'queryNames'
 //
-checkMBeanPermission(mbeanServerName,(String) null, null, null, "queryNames");
+checkMBeanPermission((String) null, null, null, "queryNames");
 // Perform query without "query".
 //
 Set<ObjectInstance> list = queryMBeansImpl(name, null);
 //
 Set<ObjectInstance> allowedList =
 new HashSet<ObjectInstance>(list.size());
 for (ObjectInstance oi : list) {
 try {
-checkMBeanPermission(mbeanServerName, oi.getClassName(), null,
+checkMBeanPermission(oi.getClassName(), null,
 oi.getObjectName(), "queryNames");
 allowedList.add(oi);
 } catch (SecurityException e) {
 // OK: Do not add this ObjectInstance to the list
 }
 public String[] getDomains()  {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
 // Check if the caller has the right to invoke 'getDomains'
 //
-checkMBeanPermission(mbeanServerName, (String) null, null, null, "getDomains");
+checkMBeanPermission((String) null, null, null, "getDomains");
 // Return domains
 //
 String[] domains = repository.getDomains();
 // on each specific domain in the list.
 //
 List<String> result = new ArrayList<String>(domains.length);
 for (int i = 0; i < domains.length; i++) {
 try {
-ObjectName dom = ObjectName.valueOf(domains[i] + ":x=x");
+ObjectName dom = Util.newObjectName(domains[i] + ":x=x");
-checkMBeanPermission(mbeanServerName, (String) null, null, dom, "getDomains");
+checkMBeanPermission((String) null, null, dom, "getDomains");
 result.add(domains[i]);
 } catch (SecurityException e) {
 // OK: Do not add this domain to the list
 }
 }
 "getAttribute",
 "Attribute = " + attribute + ", ObjectName = " + name);
 }
 final DynamicMBean instance = getMBean(name);
-checkMBeanPermission(mbeanServerName, instance, attribute,
+checkMBeanPermission(instance, attribute, name, "getAttribute");
-name, "getAttribute");
 try {
 return instance.getAttribute(attribute);
 } catch (AttributeNotFoundException e) {
 throw e;
 else {
 final String classname = getClassName(instance);
 // Check if the caller has the right to invoke 'getAttribute'
 //
-checkMBeanPermission(mbeanServerName, classname, null, name, "getAttribute");
+checkMBeanPermission(classname, null, name, "getAttribute");
 // Check if the caller has the right to invoke 'getAttribute'
 // on each specific attribute
 //
 List<String> allowedList =
 new ArrayList<String>(attributes.length);
 for (String attr : attributes) {
 try {
-checkMBeanPermission(mbeanServerName, classname, attr,
+checkMBeanPermission(classname, attr, name, "getAttribute");
-name, "getAttribute");
 allowedList.add(attr);
 } catch (SecurityException e) {
 // OK: Do not add this attribute to the list
 }
 }
 "setAttribute", "ObjectName = " + name +
 ", Attribute = " + attribute.getName());
 }
 DynamicMBean instance = getMBean(name);
-checkMBeanPermission(mbeanServerName, instance, attribute.getName(),
+checkMBeanPermission(instance, attribute.getName(), name, "setAttribute");
-name, "setAttribute");
 try {
 instance.setAttribute(attribute);
 } catch (AttributeNotFoundException e) {
 throw e;
 else {
 String classname = getClassName(instance);
 // Check if the caller has the right to invoke 'setAttribute'
 //
-checkMBeanPermission(mbeanServerName, classname, null, name, "setAttribute");
+checkMBeanPermission(classname, null, name, "setAttribute");
 // Check if the caller has the right to invoke 'setAttribute'
 // on each specific attribute
 //
 allowedAttributes = new AttributeList(attributes.size());
 for (Attribute attribute : attributes.asList()) {
 try {
-checkMBeanPermission(mbeanServerName, classname, attribute.getName(),
+checkMBeanPermission(classname, attribute.getName(),
 name, "setAttribute");
 allowedAttributes.add(attribute);
 } catch (SecurityException e) {
 // OK: Do not add this attribute to the list
 }
 ReflectionException {
 name = nonDefaultDomain(name);
 DynamicMBean instance = getMBean(name);
-checkMBeanPermission(mbeanServerName, instance, operationName,
+checkMBeanPermission(instance, operationName, name, "invoke");
-name, "invoke");
 try {
 return instance.invoke(operationName, params, signature);
 } catch (Throwable t) {
 rethrowMaybeMBeanException(t);
 throw new AssertionError();
 "Exception occurred trying to register the MBean");
 }
 DynamicMBean mbean = Introspector.makeDynamicMBean(object);
-//Access the ObjectName template value only if the provided name is null
-if(name == null) {
-name = Introspector.templateToObjectName(mbean.getMBeanInfo().
-getDescriptor(), mbean);
-}
 return registerDynamicMBean(classname, mbean, name);
 }
 private ObjectInstance registerDynamicMBean(String classname,
 DynamicMBean mbean,
 boolean registered = false;
 boolean registerFailed = false;
 ResourceContext context = null;
 try {
-mbean = injectResources(mbean, server, logicalName);
 if (mbean instanceof DynamicMBean2) {
 try {
 ((DynamicMBean2) mbean).preRegister2(server, logicalName);
 registerFailed = true;  // until we succeed
 } catch (Exception e) {
 if (logicalName != name && logicalName != null) {
 logicalName =
 ObjectName.getInstance(nonDefaultDomain(logicalName));
 }
-checkMBeanPermission(mbeanServerName, classname, null, logicalName,
+checkMBeanPermission(classname, null, logicalName, "registerMBean");
-"registerMBean");
 if (logicalName == null) {
 final RuntimeException wrapped =
 new IllegalArgumentException("No object name specified");
 throw new RuntimeOperationsException(wrapped,
 final Object resource = getResource(mbean);
 // Register the MBean with the repository.
 // Returns the resource context that was used.
 // The returned context does nothing for regular MBeans.
-// For ClassLoader MBeans and JMXNamespace (and JMXDomain)
+// For ClassLoader MBeans the context makes it possible to register these
-// MBeans - the context makes it possible to register these
 // objects with the appropriate framework artifacts, such as
-// the CLR or the dispatcher, from within the repository lock.
+// the CLR, from within the repository lock.
 // In case of success, we also need to call context.done() at the
 // end of this method.
 //
 context = registerWithRepository(resource, mbean, logicalName);
 throwMBeanRegistrationException(t, "in preRegister method");
 }
 if (newName != null) return newName;
 else return name;
-}
-private static DynamicMBean injectResources(
-DynamicMBean mbean, MBeanServer mbs, ObjectName name)
-throws MBeanRegistrationException {
-try {
-Object resource = getResource(mbean);
-MBeanInjector.inject(resource, mbs, name);
-if (MBeanInjector.injectsSendNotification(resource)) {
-MBeanNotificationInfo[] mbnis =
-mbean.getMBeanInfo().getNotifications();
-NotificationBroadcasterSupport nbs =
-new NotificationBroadcasterSupport(mbnis);
-MBeanInjector.injectSendNotification(resource, nbs);
-mbean = NotifySupport.wrap(mbean, nbs);
-}
-return mbean;
-} catch (Throwable t) {
-throwMBeanRegistrationException(t, "injecting @Resources");
-return null;  // not reached
-}
 }
 private static void postRegister(
 ObjectName logicalName, DynamicMBean mbean,
 boolean registrationDone, boolean registerFailed) {
 }
 return obj;
 }
 private static Object getResource(DynamicMBean mbean) {
-if (mbean instanceof DynamicWrapperMBean)
+if (mbean instanceof DynamicMBean2)
-return ((DynamicWrapperMBean) mbean).getWrappedObject();
+return ((DynamicMBean2) mbean).getResource();
 else
 return mbean;
-}
-private static ClassLoader getResourceLoader(DynamicMBean mbean) {
-if (mbean instanceof DynamicWrapperMBean)
-return ((DynamicWrapperMBean) mbean).getWrappedClassLoader();
-else
-return mbean.getClass().getClassLoader();
 }
 private ObjectName nonDefaultDomain(ObjectName name) {
 if (name == null || name.getDomain().length() > 0)
 return name;
 fact that toString() works like that and that it
 leaves wildcards in place (so we can detect an error
 if one is supplied where it shouldn't be).  */
 final String completeName = domain + name;
-return ObjectName.valueOf(completeName);
+return Util.newObjectName(completeName);
 }
 public String getDefaultDomain()  {
 return domain;
 }
 DefaultMBeanServerInterceptor.class.getName(),
 "addNotificationListener", "ObjectName = " + name);
 }
 DynamicMBean instance = getMBean(name);
-checkMBeanPermission(mbeanServerName, instance, null,
+checkMBeanPermission(instance, null, name, "addNotificationListener");
-name, "addNotificationListener");
 NotificationBroadcaster broadcaster =
 getNotificationBroadcaster(name, instance,
 NotificationBroadcaster.class);
 DefaultMBeanServerInterceptor.class.getName(),
 "removeNotificationListener", "ObjectName = " + name);
 }
 DynamicMBean instance = getMBean(name);
-checkMBeanPermission(mbeanServerName, instance, null, name,
+checkMBeanPermission(instance, null, name, "removeNotificationListener");
-"removeNotificationListener");
 /* We could simplify the code by assigning broadcaster after
 assigning listenerWrapper, but that would change the error
 behavior when both the broadcaster and the listener are
 erroneous.  */
 private static <T extends NotificationBroadcaster>
 T getNotificationBroadcaster(ObjectName name, Object instance,
 Class<T> reqClass) {
 if (reqClass.isInstance(instance))
 return reqClass.cast(instance);
-if (instance instanceof DynamicWrapperMBean)
+if (instance instanceof DynamicMBean2)
-instance = ((DynamicWrapperMBean) instance).getWrappedObject();
+instance = ((DynamicMBean2) instance).getResource();
 if (reqClass.isInstance(instance))
 return reqClass.cast(instance);
 final RuntimeException exc =
 new IllegalArgumentException(name.getCanonicalName());
 final String msg =
 }
 if (mbi == null)
 throw new JMRuntimeException("MBean " + name +
 "has no MBeanInfo");
-checkMBeanPermission(mbeanServerName, mbi.getClassName(), null, name, "getMBeanInfo");
+checkMBeanPermission(mbi.getClassName(), null, name, "getMBeanInfo");
 return mbi;
 }
 public boolean isInstanceOf(ObjectName name, String className)
 throws InstanceNotFoundException {
 final DynamicMBean instance = getMBean(name);
-checkMBeanPermission(mbeanServerName,
+checkMBeanPermission(instance, null, name, "isInstanceOf");
-instance, null, name, "isInstanceOf");
 try {
 Object resource = getResource(instance);
 final String resourceClassName =
 getClassName((DynamicMBean) resource) :
 resource.getClass().getName();
 if (resourceClassName.equals(className))
 return true;
-final ClassLoader cl = getResourceLoader(instance);
+final ClassLoader cl = resource.getClass().getClassLoader();
 final Class<?> classNameClass = Class.forName(className, false, cl);
 if (classNameClass.isInstance(resource))
-return true;
-// Ensure that isInstanceOf(NotificationEmitter) is true when
-// the MBean is a NotificationEmitter by virtue of a @Resource
-// annotation specifying a SendNotification resource.
-// This is a hack.
-if (instance instanceof NotificationBroadcaster &&
-classNameClass.isAssignableFrom(NotificationEmitter.class))
 return true;
 final Class<?> resourceClass = Class.forName(resourceClassName, false, cl);
 return classNameClass.isAssignableFrom(resourceClass);
 } catch (Exception x) {
 */
 public ClassLoader getClassLoaderFor(ObjectName mbeanName)
 throws InstanceNotFoundException {
 DynamicMBean instance = getMBean(mbeanName);
-checkMBeanPermission(mbeanServerName, instance, null, mbeanName,
+checkMBeanPermission(instance, null, mbeanName, "getClassLoaderFor");
-"getClassLoaderFor");
+return getResource(instance).getClass().getClassLoader();
-return getResourceLoader(instance);
 }
 /**
 * <p>Return the named {@link java.lang.ClassLoader}.
 * @param loaderName The ObjectName of the ClassLoader.
 */
 public ClassLoader getClassLoader(ObjectName loaderName)
 throws InstanceNotFoundException {
 if (loaderName == null) {
-checkMBeanPermission(mbeanServerName, (String) null, null, null, "getClassLoader");
+checkMBeanPermission((String) null, null, null, "getClassLoader");
 return server.getClass().getClassLoader();
 }
 DynamicMBean instance = getMBean(loaderName);
-checkMBeanPermission(mbeanServerName, instance, null, loaderName,
+checkMBeanPermission(instance, null, loaderName, "getClassLoader");
-"getClassLoader");
 Object resource = getResource(instance);
 /* Check if the given MBean is a ClassLoader */
 if (!(resource instanceof ClassLoader))
 } else
 return null;
 }
 }
+public Object instantiate(String className) throws ReflectionException,
+MBeanException {
+throw new UnsupportedOperationException("Not supported yet.");
+}
+public Object instantiate(String className, ObjectName loaderName) throws ReflectionException,
+MBeanException,
+InstanceNotFoundException {
+throw new UnsupportedOperationException("Not supported yet.");
+}
+public Object instantiate(String className, Object[] params,
+String[] signature) throws ReflectionException, MBeanException {
+throw new UnsupportedOperationException("Not supported yet.");
+}
+public Object instantiate(String className, ObjectName loaderName,
+Object[] params, String[] signature) throws ReflectionException,
+MBeanException,
+InstanceNotFoundException {
+throw new UnsupportedOperationException("Not supported yet.");
+}
+public ObjectInputStream deserialize(ObjectName name, byte[] data) throws InstanceNotFoundException,
+OperationsException {
+throw new UnsupportedOperationException("Not supported yet.");
+}
+public ObjectInputStream deserialize(String className, byte[] data) throws OperationsException,
+ReflectionException {
+throw new UnsupportedOperationException("Not supported yet.");
+}
+public ObjectInputStream deserialize(String className, ObjectName loaderName,
+byte[] data) throws InstanceNotFoundException, OperationsException,
+ReflectionException {
+throw new UnsupportedOperationException("Not supported yet.");
+}
+public ClassLoaderRepository getClassLoaderRepository() {
+throw new UnsupportedOperationException("Not supported yet.");
+}
 private static class ListenerWrapper implements NotificationListener {
 ListenerWrapper(NotificationListener l, ObjectName name,
 Object mbean) {
 this.listener = l;
 this.name = name;
 return ((DynamicMBean2) mbean).getClassName();
 else
 return mbean.getMBeanInfo().getClassName();
 }
-private static void checkMBeanPermission(String mbeanServerName,
+private static void checkMBeanPermission(DynamicMBean mbean,
-DynamicMBean mbean,
 String member,
 ObjectName objectName,
 String actions) {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
-checkMBeanPermission(mbeanServerName,
+checkMBeanPermission(safeGetClassName(mbean),
-safeGetClassName(mbean),
 member,
 objectName,
 actions);
 }
 }
-private static void checkMBeanPermission(String mbeanServerName,
+private static void checkMBeanPermission(String classname,
-String classname,
 String member,
 ObjectName objectName,
 String actions) {
 SecurityManager sm = System.getSecurityManager();
 if (sm != null) {
-Permission perm = new MBeanPermission(mbeanServerName,
+Permission perm = new MBeanPermission(classname,
-classname,
 member,
 objectName,
 actions);
 sm.checkPermission(perm);
 }
 final DynamicMBean object,
 final ObjectName logicalName)
 throws InstanceAlreadyExistsException,
 MBeanRegistrationException {
-// this will throw an exception if the pair (resource, logicalName)
-// violates namespace conventions - for instance, if logicalName
-// ends with // but resource is not a JMXNamespace.
-//
-checkResourceObjectNameConstraints(resource, logicalName);
 // Creates a registration context, if needed.
 //
 final ResourceContext context =
 makeResourceContextFor(resource, logicalName);
 sendNotification(MBeanServerNotification.UNREGISTRATION_NOTIFICATION,
 logicalName);
 return context;
 }
-/**
-* Checks that the ObjectName is legal with regards to the
-* type of the MBean resource.
-* If the MBean name is  domain:type=JMXDomain, the
-*     MBean must be a JMXDomain.
-* If the MBean name is  namespace//:type=JMXNamespace, the
-*     MBean must be a JMXNamespace.
-* If the MBean is a JMXDomain, its name
-*      must be domain:type=JMXDomain.
-* If the MBean is a JMXNamespace,  its name
-*      must be namespace//:type=JMXNamespace.
-*/
-private void checkResourceObjectNameConstraints(Object resource,
-ObjectName logicalName)
-throws MBeanRegistrationException {
-try {
-dispatcher.checkLocallyRegistrable(resource, logicalName);
-} catch (Throwable x) {
-DefaultMBeanServerInterceptor.throwMBeanRegistrationException(x, "validating ObjectName");
-}
-}
-/**
-* Registers a JMXNamespace with the dispatcher.
-* This method is called by the ResourceContext from within the
-* repository lock.
-* @param namespace    The JMXNamespace
-* @param logicalName  The JMXNamespaceMBean ObjectName
-* @param postQueue    A queue that will be processed after postRegister.
-*/
-private void addJMXNamespace(JMXNamespace namespace,
-final ObjectName logicalName,
-final Queue<Runnable> postQueue) {
-dispatcher.addInterceptorFor(logicalName, namespace, postQueue);
-}
-/**
-* Unregisters a JMXNamespace from the dispatcher.
-* This method is called by the ResourceContext from within the
-* repository lock.
-* @param namespace    The JMXNamespace
-* @param logicalName  The JMXNamespaceMBean ObjectName
-* @param postQueue    A queue that will be processed after postDeregister.
-*/
-private void removeJMXNamespace(JMXNamespace namespace,
-final ObjectName logicalName,
-final Queue<Runnable> postQueue) {
-dispatcher.removeInterceptorFor(logicalName, namespace, postQueue);
-}
 /**
 * Registers a ClassLoader with the CLR.
 * This method is called by the ResourceContext from within the
 * repository lock.
 }
 }
 /**
-* Creates a ResourceContext for a JMXNamespace MBean.
-* The resource context makes it possible to add the JMXNamespace to
-* (ResourceContext.registering) or resp. remove the JMXNamespace from
-* (ResourceContext.unregistered) the NamespaceDispatchInterceptor
-* when the associated MBean is added to or resp. removed from the
-* repository.
-* Note: JMXDomains are special sub classes of JMXNamespaces and
-*       are also handled by this object.
-*
-* @param namespace    The JMXNamespace MBean being registered or
-*                     unregistered.
-* @param logicalName  The name of the JMXNamespace MBean.
-* @return a ResourceContext that takes in charge the addition or removal
-*         of the namespace to or from the NamespaceDispatchInterceptor.
-*/
-private ResourceContext createJMXNamespaceContext(
-final JMXNamespace namespace,
-final ObjectName logicalName) {
-final Queue<Runnable> doneTaskQueue = new LinkedList<Runnable>();
-return new ResourceContext() {
-public void registering() {
-addJMXNamespace(namespace, logicalName, doneTaskQueue);
-}
-public void unregistered() {
-removeJMXNamespace(namespace, logicalName,
-doneTaskQueue);
-}
-public void done() {
-for (Runnable r : doneTaskQueue) {
-try {
-r.run();
-} catch (RuntimeException x) {
-MBEANSERVER_LOGGER.log(Level.FINE,
-"Failed to process post queue for "+
-logicalName, x);
-}
-}
-}
-};
-}
-/**
 * Creates a ResourceContext for a ClassLoader MBean.
 * The resource context makes it possible to add the ClassLoader to
 * (ResourceContext.registering) or resp. remove the ClassLoader from
 * (ResourceContext.unregistered) the CLR
 * when the associated MBean is added to or resp. removed from the
 /**
 * Creates a ResourceContext for the given resource.
 * If the resource does not need a ResourceContext, returns
 * ResourceContext.NONE.
-* At this time, only JMXNamespaces and ClassLoaders need a
+* At this time, only ClassLoaders need a ResourceContext.
-* ResourceContext.
 *
 * @param resource     The resource being registered or unregistered.
 * @param logicalName  The name of the associated MBean.
 * @return
 */
 private ResourceContext makeResourceContextFor(Object resource,
 ObjectName logicalName) {
-if (resource instanceof JMXNamespace) {
-return createJMXNamespaceContext((JMXNamespace) resource,
-logicalName);
-}
 if (resource instanceof ClassLoader) {
 return createClassLoaderContext((ClassLoader) resource,
 logicalName);
 }
 return ResourceContext.NONE;

changeset 4156	acaa49a2768a
parent 1700	4506662fb2ee
child 5506	202f599c92aa