| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.felix.mosgi.jmx.agent.mx4j.server; |
| |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.ObjectInputStream; |
| import java.security.AccessController; |
| import java.security.PrivilegedAction; |
| import java.security.PrivilegedActionException; |
| import java.security.PrivilegedExceptionAction; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import javax.management.Attribute; |
| import javax.management.AttributeList; |
| import javax.management.AttributeNotFoundException; |
| import javax.management.BadAttributeValueExpException; |
| import javax.management.BadBinaryOpValueExpException; |
| import javax.management.BadStringOperationException; |
| import javax.management.InstanceAlreadyExistsException; |
| import javax.management.InstanceNotFoundException; |
| import javax.management.IntrospectionException; |
| import javax.management.InvalidApplicationException; |
| import javax.management.InvalidAttributeValueException; |
| import javax.management.JMRuntimeException; |
| 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.MBeanServerNotification; |
| import javax.management.MBeanServerPermission; |
| import javax.management.MalformedObjectNameException; |
| import javax.management.NotCompliantMBeanException; |
| import javax.management.NotificationBroadcaster; |
| 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.QueryExp; |
| import javax.management.ReflectionException; |
| import javax.management.RuntimeErrorException; |
| import javax.management.RuntimeOperationsException; |
| import javax.management.StandardMBean; |
| import javax.management.loading.ClassLoaderRepository; |
| import javax.management.loading.PrivateClassLoader; |
| |
| import org.apache.felix.mosgi.jmx.agent.mx4j.ImplementationException; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.MX4JSystemKeys; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.loading.ClassLoaderObjectInputStream; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.log.Log; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.log.Logger; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.server.interceptor.InvokerMBeanServerInterceptor; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.server.interceptor.MBeanServerInterceptor; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.server.interceptor.MBeanServerInterceptorConfigurator; |
| import org.apache.felix.mosgi.jmx.agent.mx4j.util.Utils; |
| |
| /** |
| * The MX4J MBeanServer implementation. <br> |
| * The MBeanServer accomplishes these roles: |
| * <ul> |
| * <li> Returns information about the Agent |
| * <li> Acts as a repository for MBeans |
| * <li> Acts as an invoker, on behalf of the user, on MBeans |
| * </ul> |
| * <br> |
| * The repository function is delegated to instances of {@link MBeanRepository} classes. |
| * This class acts as a factory for MBeanRepository instances, that can be controlled via the system property |
| * {@link mx4j.MX4JSystemKeys#MX4J_MBEANSERVER_REPOSITORY} to the qualified name of the implementation class. <br> |
| * |
| * This class also acts as an invoker on MBeans. The architecture is interceptor-based, that is whenever you call |
| * from a client an MBeanServer method that will end up to call the MBean instance, the call is dispatched to |
| * the interceptor chain and eventually to the MBean. <br> |
| * The interceptors are configurable via the MBean {@link MBeanServerInterceptorConfigurator}. |
| * When the call is about to arrive to the MBean instance, the last interceptor dispatches the call depending on |
| * the MBean type: if the MBean is a dynamic MBean, the call is dispatched directly; if the MBean is a standard |
| * MBean an {@link MBeanInvoker} is delegated to invoke on the MBean instance. |
| * |
| * @author <a href="mailto:biorn_steedom@users.sourceforge.net">Simone Bordet</a> |
| * @version $Revision: 1.3 $ |
| */ |
| public class MX4JMBeanServer implements MBeanServer, java.io.Serializable |
| { |
| private String defaultDomain; |
| private MBeanRepository mbeanRepository; |
| private MBeanServerDelegate delegate; |
| private ObjectName delegateName; |
| private MBeanIntrospector introspector; |
| private MBeanServerInterceptorConfigurator invoker; |
| private static long notifications; |
| private ModifiableClassLoaderRepository classLoaderRepository; |
| private Map domains = new HashMap(); |
| |
| private static final String[] EMPTY_PARAMS = new String[0]; |
| private static final Object[] EMPTY_ARGS = new Object[0]; |
| |
| /** |
| * Create a new MBeanServer implementation with the specified default domain. |
| * If the default domain is null, then the empty string is assumed. |
| * |
| * @param defaultDomain The default domain to be used |
| * @throws SecurityException if access is not granted to create an MBeanServer instance |
| */ |
| public MX4JMBeanServer(String defaultDomain, MBeanServer outer, MBeanServerDelegate delegate) |
| { |
| Logger logger = getLogger(); |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Creating MBeanServer instance..."); |
| |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Checking permission to create MBeanServer..."); |
| sm.checkPermission(new MBeanServerPermission("newMBeanServer")); |
| } |
| |
| if (defaultDomain == null) defaultDomain = ""; |
| this.defaultDomain = defaultDomain; |
| |
| if (delegate==null) throw new JMRuntimeException("Delegate can't be null"); |
| this.delegate = delegate; |
| |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("MBeanServer default domain is: '" + this.defaultDomain + "'"); |
| |
| mbeanRepository = createMBeanRepository(); |
| |
| classLoaderRepository = createClassLoaderRepository(); |
| // JMX 1.2 requires the CLR to have as first entry the classloader of this class |
| classLoaderRepository.addClassLoader(getClass().getClassLoader()); |
| |
| introspector = new MBeanIntrospector(); |
| |
| // This is the official name of the delegate, it is used as a source for MBeanServerNotifications |
| try |
| { |
| delegateName = new ObjectName("JMImplementation", "type", "MBeanServerDelegate"); |
| } |
| catch (MalformedObjectNameException ignored) |
| { |
| } |
| |
| try |
| { |
| ObjectName invokerName = new ObjectName(MBeanServerInterceptorConfigurator.OBJECT_NAME); |
| invoker = new MBeanServerInterceptorConfigurator(this); |
| |
| // ContextClassLoaderMBeanServerInterceptor ccl = new ContextClassLoaderMBeanServerInterceptor(); |
| // NotificationListenerMBeanServerInterceptor notif = new NotificationListenerMBeanServerInterceptor(); |
| // SecurityMBeanServerInterceptor sec = new SecurityMBeanServerInterceptor(); |
| InvokerMBeanServerInterceptor inv = new InvokerMBeanServerInterceptor(outer==null ? this : outer); |
| |
| // invoker.addPreInterceptor(ccl); |
| // invoker.addPreInterceptor(notif); |
| // invoker.addPostInterceptor(sec); |
| invoker.addPostInterceptor(inv); |
| |
| invoker.start(); |
| |
| // The interceptor stack is in place, register the configurator and all interceptors |
| privilegedRegisterMBean(invoker, invokerName); |
| |
| // ObjectName cclName = new ObjectName("JMImplementation", "interceptor", "contextclassloader"); |
| // ObjectName notifName = new ObjectName("JMImplementation", "interceptor", "notificationwrapper"); |
| // ObjectName secName = new ObjectName("JMImplementation", "interceptor", "security"); |
| ObjectName invName = new ObjectName("JMImplementation", "interceptor", "invoker"); |
| |
| // privilegedRegisterMBean(ccl, cclName); |
| // privilegedRegisterMBean(notif, notifName); |
| // privilegedRegisterMBean(sec, secName); |
| privilegedRegisterMBean(inv, invName); |
| } |
| catch (Exception x) |
| { |
| logger.error("MBeanServerInterceptorConfigurator cannot be registered", x); |
| throw new ImplementationException(); |
| } |
| |
| // Now register the delegate |
| try |
| { |
| privilegedRegisterMBean(delegate, delegateName); |
| } |
| catch (Exception x) |
| { |
| logger.error("MBeanServerDelegate cannot be registered", x); |
| throw new ImplementationException(x.toString()); |
| } |
| |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("MBeanServer instance created successfully"); |
| } |
| |
| /** |
| * Returns the ClassLoaderRepository for this MBeanServer. |
| * When first the ClassLoaderRepository is created in the constructor, the system property |
| * {@link mx4j.MX4JSystemKeys#MX4J_MBEANSERVER_CLASSLOADER_REPOSITORY} is tested; |
| * if it is non-null and defines a subclass of |
| * {@link ModifiableClassLoaderRepository}, then that class is used instead of the default one. |
| */ |
| public ClassLoaderRepository getClassLoaderRepository() |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| sm.checkPermission(new MBeanPermission("-#-[-]", "getClassLoaderRepository")); |
| } |
| |
| return getModifiableClassLoaderRepository(); |
| } |
| |
| private ModifiableClassLoaderRepository getModifiableClassLoaderRepository() |
| { |
| return classLoaderRepository; |
| } |
| |
| public ClassLoader getClassLoader(ObjectName name) throws InstanceNotFoundException |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| name = secureObjectName(name); |
| |
| if (name == null) |
| { |
| sm.checkPermission(new MBeanPermission("-#-[-]", "getClassLoader")); |
| } |
| else |
| { |
| MBeanMetaData metadata = findMBeanMetaData(name); |
| sm.checkPermission(new MBeanPermission(metadata.info.getClassName(), "-", name, "getClassLoader")); |
| } |
| } |
| |
| return getClassLoaderImpl(name); |
| } |
| |
| public ClassLoader getClassLoaderFor(ObjectName name) throws InstanceNotFoundException |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| name = secureObjectName(name); |
| } |
| |
| // If name is null, I get InstanceNotFoundException |
| MBeanMetaData metadata = findMBeanMetaData(name); |
| |
| if (sm != null) |
| { |
| sm.checkPermission(new MBeanPermission(metadata.info.getClassName(), "-", name, "getClassLoaderFor")); |
| } |
| |
| return metadata.mbean.getClass().getClassLoader(); |
| } |
| |
| /** |
| * Returns the MBean classloader corrispondent to the given ObjectName. |
| * If <code>name</code> is null, the classloader of this class is returned. |
| */ |
| private ClassLoader getClassLoaderImpl(ObjectName name) throws InstanceNotFoundException |
| { |
| if (name == null) |
| { |
| return getClass().getClassLoader(); |
| } |
| else |
| { |
| MBeanMetaData metadata = findMBeanMetaData(name); |
| if (metadata.mbean instanceof ClassLoader) |
| { |
| return (ClassLoader)metadata.mbean; |
| } |
| else |
| { |
| throw new InstanceNotFoundException(name.getCanonicalName()); |
| } |
| } |
| } |
| |
| public ObjectInputStream deserialize(String className, ObjectName loaderName, byte[] bytes) |
| throws InstanceNotFoundException, OperationsException, ReflectionException |
| { |
| if (className == null || className.trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid class name '" + className + "'")); |
| } |
| |
| ClassLoader cl = getClassLoader(loaderName); |
| |
| try |
| { |
| Class cls = cl.loadClass(className); |
| return deserializeImpl(cls.getClassLoader(), bytes); |
| } |
| catch (ClassNotFoundException x) |
| { |
| throw new ReflectionException(x); |
| } |
| } |
| |
| public ObjectInputStream deserialize(String className, byte[] bytes) |
| throws OperationsException, ReflectionException |
| { |
| if (className == null || className.trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid class name '" + className + "'")); |
| } |
| |
| // Find the classloader that can load the given className using the ClassLoaderRepository |
| try |
| { |
| Class cls = getClassLoaderRepository().loadClass(className); |
| return deserializeImpl(cls.getClassLoader(), bytes); |
| } |
| catch (ClassNotFoundException x) |
| { |
| throw new ReflectionException(x); |
| } |
| } |
| |
| public ObjectInputStream deserialize(ObjectName objectName, byte[] bytes) |
| throws InstanceNotFoundException, OperationsException |
| { |
| ClassLoader cl = getClassLoaderFor(objectName); |
| return deserializeImpl(cl, bytes); |
| } |
| |
| /** |
| * Deserializes the given bytes using the specified classloader. |
| */ |
| private ObjectInputStream deserializeImpl(ClassLoader classloader, byte[] bytes) throws OperationsException |
| { |
| if (bytes == null || bytes.length == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid byte array " + bytes)); |
| } |
| |
| ByteArrayInputStream bais = new ByteArrayInputStream(bytes); |
| try |
| { |
| return new ClassLoaderObjectInputStream(bais, classloader); |
| } |
| catch (IOException x) |
| { |
| throw new OperationsException(x.toString()); |
| } |
| } |
| |
| private MBeanServerInterceptor getHeadInterceptor() |
| { |
| MBeanServerInterceptor head = invoker.getHeadInterceptor(); |
| |
| if (head == null) throw new IllegalStateException("No MBeanServer interceptor, probably the configurator has been stopped"); |
| |
| return head; |
| } |
| |
| private Logger getLogger() |
| { |
| return Log.getLogger(getClass().getName()); |
| } |
| |
| /** |
| * Creates a new repository for MBeans. |
| * The system property {@link mx4j.MX4JSystemKeys#MX4J_MBEANSERVER_REPOSITORY} is tested |
| * for a full qualified name of a class implementing the {@link MBeanRepository} interface. |
| * In case the system property is not defined or the class is not loadable or instantiable, a default |
| * implementation is returned. |
| */ |
| private MBeanRepository createMBeanRepository() |
| { |
| Logger logger = getLogger(); |
| |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Checking for system property " + MX4JSystemKeys.MX4J_MBEANSERVER_REPOSITORY); |
| |
| String value = (String)AccessController.doPrivileged(new PrivilegedAction() |
| { |
| public Object run() |
| { |
| return System.getProperty(MX4JSystemKeys.MX4J_MBEANSERVER_REPOSITORY); |
| } |
| }); |
| |
| if (value != null) |
| { |
| if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("Property found for custom MBeanServer registry; class is: " + value); |
| |
| try |
| { |
| MBeanRepository registry = (MBeanRepository)Thread.currentThread().getContextClassLoader().loadClass(value).newInstance(); |
| if (logger.isEnabledFor(Logger.TRACE)) |
| { |
| logger.trace("Custom MBeanServer registry created successfully"); |
| } |
| return registry; |
| } |
| catch (Exception x) |
| { |
| if (logger.isEnabledFor(Logger.TRACE)) |
| { |
| logger.trace("Custom MBeanServer registry could not be created", x); |
| } |
| } |
| } |
| |
| return new DefaultMBeanRepository(); |
| } |
| |
| /** |
| * Creates a new ClassLoaderRepository for ClassLoader MBeans. |
| * The system property {@link mx4j.MX4JSystemKeys#MX4J_MBEANSERVER_CLASSLOADER_REPOSITORY} |
| * is tested for a full qualified name of a class |
| * extending the {@link ModifiableClassLoaderRepository} class. |
| * In case the system property is not defined or the class is not loadable or instantiable, a default |
| * implementation is returned. |
| */ |
| private ModifiableClassLoaderRepository createClassLoaderRepository() |
| { |
| Logger logger = getLogger(); |
| |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Checking for system property " + MX4JSystemKeys.MX4J_MBEANSERVER_CLASSLOADER_REPOSITORY); |
| |
| String value = (String)AccessController.doPrivileged(new PrivilegedAction() |
| { |
| public Object run() |
| { |
| return System.getProperty(MX4JSystemKeys.MX4J_MBEANSERVER_CLASSLOADER_REPOSITORY); |
| } |
| }); |
| |
| if (value != null) |
| { |
| if (logger.isEnabledFor(Logger.DEBUG)) logger.debug("Property found for custom ClassLoaderRepository; class is: " + value); |
| |
| try |
| { |
| ModifiableClassLoaderRepository repository = (ModifiableClassLoaderRepository)Thread.currentThread().getContextClassLoader().loadClass(value).newInstance(); |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Custom ClassLoaderRepository created successfully " + repository); |
| return repository; |
| } |
| catch (Exception x) |
| { |
| if (logger.isEnabledFor(Logger.TRACE)) logger.trace("Custom ClassLoaderRepository could not be created", x); |
| } |
| } |
| return new DefaultClassLoaderRepository(); |
| } |
| |
| /** |
| * Returns the repository of MBeans for this MBeanServer |
| */ |
| private MBeanRepository getMBeanRepository() |
| { |
| return mbeanRepository; |
| } |
| |
| /** |
| * Looks up the metadata associated with the given ObjectName. |
| * @throws InstanceNotFoundException if the given ObjectName is not a registered MBean |
| */ |
| private MBeanMetaData findMBeanMetaData(ObjectName objectName) throws InstanceNotFoundException |
| { |
| MBeanMetaData metadata = null; |
| if (objectName != null) |
| { |
| objectName = normalizeObjectName(objectName); |
| |
| MBeanRepository repository = getMBeanRepository(); |
| synchronized (repository) |
| { |
| metadata = repository.get(objectName); |
| } |
| } |
| if (metadata == null) |
| { |
| throw new InstanceNotFoundException("MBeanServer cannot find MBean with ObjectName " + objectName); |
| } |
| return metadata; |
| } |
| |
| public void addNotificationListener(ObjectName observed, ObjectName listener, NotificationFilter filter, Object handback) |
| throws InstanceNotFoundException |
| { |
| listener = secureObjectName(listener); |
| |
| Object mbean = findMBeanMetaData(listener).mbean; |
| if (!(mbean instanceof NotificationListener)) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("MBean " + listener + " is not a NotificationListener")); |
| } |
| addNotificationListener(observed, (NotificationListener)mbean, filter, handback); |
| } |
| |
| public void addNotificationListener(ObjectName observed, NotificationListener listener, NotificationFilter filter, Object handback) |
| throws InstanceNotFoundException |
| { |
| if (listener == null) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("NotificationListener cannot be null")); |
| } |
| |
| observed = secureObjectName(observed); |
| |
| MBeanMetaData metadata = findMBeanMetaData(observed); |
| |
| Object mbean = metadata.mbean; |
| |
| if (!(mbean instanceof NotificationBroadcaster)) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("MBean " + observed + " is not a NotificationBroadcaster")); |
| } |
| |
| addNotificationListenerImpl(metadata, listener, filter, handback); |
| } |
| |
| private void addNotificationListenerImpl(MBeanMetaData metadata, NotificationListener listener, NotificationFilter filter, Object handback) |
| { |
| getHeadInterceptor().addNotificationListener(metadata, listener, filter, handback); |
| } |
| |
| public void removeNotificationListener(ObjectName observed, ObjectName listener) |
| throws InstanceNotFoundException, ListenerNotFoundException |
| { |
| listener = secureObjectName(listener); |
| |
| Object mbean = findMBeanMetaData(listener).mbean; |
| if (!(mbean instanceof NotificationListener)) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("MBean " + listener + " is not a NotificationListener")); |
| } |
| removeNotificationListener(observed, (NotificationListener)mbean); |
| } |
| |
| public void removeNotificationListener(ObjectName observed, NotificationListener listener) |
| throws InstanceNotFoundException, ListenerNotFoundException |
| { |
| if (listener == null) |
| { |
| throw new ListenerNotFoundException("NotificationListener cannot be null"); |
| } |
| |
| observed = secureObjectName(observed); |
| |
| MBeanMetaData metadata = findMBeanMetaData(observed); |
| Object mbean = metadata.mbean; |
| |
| if (!(mbean instanceof NotificationBroadcaster)) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("MBean " + observed + " is not a NotificationBroadcaster")); |
| } |
| |
| removeNotificationListenerImpl(metadata, listener); |
| } |
| |
| public void removeNotificationListener(ObjectName observed, ObjectName listener, NotificationFilter filter, Object handback) |
| throws InstanceNotFoundException, ListenerNotFoundException |
| { |
| listener = secureObjectName(listener); |
| |
| Object mbean = findMBeanMetaData(listener).mbean; |
| if (!(mbean instanceof NotificationListener)) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("MBean " + listener + " is not a NotificationListener")); |
| } |
| removeNotificationListener(observed, (NotificationListener)mbean, filter, handback); |
| } |
| |
| public void removeNotificationListener(ObjectName observed, NotificationListener listener, NotificationFilter filter, Object handback) |
| throws InstanceNotFoundException, ListenerNotFoundException |
| { |
| if (listener == null) |
| { |
| throw new ListenerNotFoundException("NotificationListener cannot be null"); |
| } |
| |
| observed = secureObjectName(observed); |
| |
| MBeanMetaData metadata = findMBeanMetaData(observed); |
| Object mbean = metadata.mbean; |
| |
| if (!(mbean instanceof NotificationEmitter)) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("MBean " + observed + " is not a NotificationEmitter")); |
| } |
| |
| removeNotificationListenerImpl(metadata, listener, filter, handback); |
| } |
| |
| private void removeNotificationListenerImpl(MBeanMetaData metadata, NotificationListener listener) |
| throws ListenerNotFoundException |
| { |
| getHeadInterceptor().removeNotificationListener(metadata, listener); |
| } |
| |
| private void removeNotificationListenerImpl(MBeanMetaData metadata, NotificationListener listener, NotificationFilter filter, Object handback) |
| throws ListenerNotFoundException |
| { |
| getHeadInterceptor().removeNotificationListener(metadata, listener, filter, handback); |
| } |
| |
| public Object instantiate(String className) |
| throws ReflectionException, MBeanException |
| { |
| return instantiate(className, null, null); |
| } |
| |
| public Object instantiate(String className, Object[] args, String[] parameters) |
| throws ReflectionException, MBeanException |
| { |
| if (className == null || className.trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Class name cannot be null or empty")); |
| } |
| |
| try |
| { |
| Class cls = getModifiableClassLoaderRepository().loadClass(className); |
| return instantiateImpl(className, cls.getClassLoader(), null, parameters, args).mbean; |
| } |
| catch (ClassNotFoundException x) |
| { |
| throw new ReflectionException(x); |
| } |
| } |
| |
| public Object instantiate(String className, ObjectName loaderName) |
| throws ReflectionException, MBeanException, InstanceNotFoundException |
| { |
| return instantiate(className, loaderName, null, null); |
| } |
| |
| public Object instantiate(String className, ObjectName loaderName, Object[] args, String[] parameters) |
| throws ReflectionException, MBeanException, InstanceNotFoundException |
| { |
| if (className == null || className.trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Class name cannot be null or empty")); |
| } |
| |
| // loaderName can be null: means using this class' ClassLoader |
| |
| loaderName = secureObjectName(loaderName); |
| if (loaderName != null && loaderName.isPattern()) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("ObjectName for the ClassLoader cannot be a pattern ObjectName: " + loaderName)); |
| } |
| |
| ClassLoader cl = getClassLoaderImpl(loaderName); |
| return instantiateImpl(className, cl, null, parameters, args).mbean; |
| } |
| |
| private MBeanMetaData instantiateImpl(String className, ClassLoader classloader, ObjectName name, String[] params, Object[] args) |
| throws ReflectionException, MBeanException |
| { |
| if (params == null) params = EMPTY_PARAMS; |
| if (args == null) args = EMPTY_ARGS; |
| |
| MBeanMetaData metadata = createMBeanMetaData(); |
| metadata.classloader = classloader; |
| metadata.name = secureObjectName(name); |
| |
| getHeadInterceptor().instantiate(metadata, className, params, args); |
| |
| return metadata; |
| } |
| |
| public ObjectInstance createMBean(String className, ObjectName objectName) |
| throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException |
| { |
| return createMBean(className, objectName, null, null); |
| } |
| |
| public ObjectInstance createMBean(String className, ObjectName objectName, Object[] args, String[] parameters) |
| throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException |
| { |
| try |
| { |
| Class cls = getModifiableClassLoaderRepository().loadClass(className); |
| MBeanMetaData metadata = instantiateImpl(className, cls.getClassLoader(), objectName, parameters, args); |
| |
| registerImpl(metadata, false); |
| |
| return metadata.instance; |
| } |
| catch (ClassNotFoundException x) |
| { |
| throw new ReflectionException(x); |
| } |
| } |
| |
| public ObjectInstance createMBean(String className, ObjectName objectName, ObjectName loaderName) |
| throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException |
| { |
| return createMBean(className, objectName, loaderName, null, null); |
| } |
| |
| public ObjectInstance createMBean(String className, ObjectName objectName, ObjectName loaderName, Object[] args, String[] parameters) |
| throws ReflectionException, InstanceAlreadyExistsException, MBeanRegistrationException, MBeanException, NotCompliantMBeanException, InstanceNotFoundException |
| { |
| loaderName = secureObjectName(loaderName); |
| |
| ClassLoader cl = getClassLoaderImpl(loaderName); |
| |
| MBeanMetaData metadata = instantiateImpl(className, cl, objectName, parameters, args); |
| |
| registerImpl(metadata, false); |
| |
| return metadata.instance; |
| } |
| |
| public ObjectInstance registerMBean(Object mbean, ObjectName objectName) |
| throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException |
| { |
| return registerMBeanImpl(mbean, objectName, false); |
| } |
| |
| private ObjectInstance registerMBeanImpl(Object mbean, ObjectName objectName, boolean privileged) |
| throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException |
| { |
| if (mbean == null) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("MBean instance cannot be null")); |
| } |
| |
| MBeanMetaData metadata = createMBeanMetaData(); |
| metadata.mbean = mbean; |
| metadata.classloader = mbean.getClass().getClassLoader(); |
| metadata.name = secureObjectName(objectName); |
| |
| registerImpl(metadata, privileged); |
| |
| return metadata.instance; |
| } |
| |
| /** |
| * Returns a new instance of the metadata class used to store MBean information. |
| */ |
| private MBeanMetaData createMBeanMetaData() |
| { |
| return new MBeanMetaData(); |
| } |
| |
| /** |
| * This method is called only to register implementation MBeans from the constructor. |
| * Since to create an instance of this class already requires a permission, here we hide the registration |
| * of implementation MBeans to the client that thus need no further permissions. |
| */ |
| private ObjectInstance privilegedRegisterMBean(final Object mbean, final ObjectName name) |
| throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException |
| { |
| try |
| { |
| return (ObjectInstance)AccessController.doPrivileged(new PrivilegedExceptionAction() |
| { |
| public Object run() throws Exception |
| { |
| return registerMBeanImpl(mbean, name, true); |
| } |
| }); |
| } |
| catch (PrivilegedActionException x) |
| { |
| Exception xx = x.getException(); |
| if (xx instanceof InstanceAlreadyExistsException) |
| throw (InstanceAlreadyExistsException)xx; |
| else if (xx instanceof MBeanRegistrationException) |
| throw (MBeanRegistrationException)xx; |
| else if (xx instanceof NotCompliantMBeanException) |
| throw (NotCompliantMBeanException)xx; |
| else |
| throw new MBeanRegistrationException(xx); |
| } |
| } |
| |
| private void registerImpl(MBeanMetaData metadata, boolean privileged) throws InstanceAlreadyExistsException, MBeanRegistrationException, NotCompliantMBeanException |
| { |
| introspector.introspect(metadata); |
| |
| if (!introspector.isMBeanCompliant(metadata)) throw new NotCompliantMBeanException("MBean is not compliant"); |
| |
| MBeanServerInterceptor head = getHeadInterceptor(); |
| |
| try |
| { |
| // With this call, the MBean implementor can replace the ObjectName with a subclass that is not secure, secure it again |
| head.registration(metadata, MBeanServerInterceptor.PRE_REGISTER); |
| metadata.name = secureObjectName(metadata.name); |
| |
| metadata.instance = new ObjectInstance(metadata.name, metadata.info.getClassName()); |
| |
| register(metadata, privileged); |
| |
| head.registration(metadata, MBeanServerInterceptor.POST_REGISTER_TRUE); |
| } |
| catch (Throwable x) |
| { |
| try |
| { |
| head.registration(metadata, MBeanServerInterceptor.POST_REGISTER_FALSE); |
| } |
| catch (MBeanRegistrationException ignored) |
| {/* Ignore this one to rethrow the other one */ |
| } |
| |
| if (x instanceof SecurityException) |
| { |
| throw (SecurityException)x; |
| } |
| else if (x instanceof InstanceAlreadyExistsException) |
| { |
| throw (InstanceAlreadyExistsException)x; |
| } |
| else if (x instanceof MBeanRegistrationException) |
| { |
| throw (MBeanRegistrationException)x; |
| } |
| else if (x instanceof RuntimeOperationsException) |
| { |
| throw (RuntimeOperationsException)x; |
| } |
| else if (x instanceof JMRuntimeException) |
| { |
| throw (JMRuntimeException)x; |
| } |
| else if (x instanceof Exception) |
| { |
| throw new MBeanRegistrationException((Exception)x); |
| } |
| else if (x instanceof Error) |
| { |
| throw new MBeanRegistrationException(new RuntimeErrorException((Error)x)); |
| } |
| else |
| { |
| throw new ImplementationException(); |
| } |
| } |
| |
| if (metadata.mbean instanceof ClassLoader && !(metadata.mbean instanceof PrivateClassLoader)) |
| { |
| ClassLoader cl = (ClassLoader)metadata.mbean; |
| getModifiableClassLoaderRepository().addClassLoader(cl); |
| } |
| } |
| |
| private void register(MBeanMetaData metadata, boolean privileged) throws InstanceAlreadyExistsException |
| { |
| metadata.name = normalizeObjectName(metadata.name); |
| |
| ObjectName objectName = metadata.name; |
| if (objectName == null || objectName.isPattern()) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("ObjectName cannot be null or a pattern ObjectName")); |
| } |
| if (objectName.getDomain().equals("JMImplementation") && !privileged) |
| { |
| throw new JMRuntimeException("Domain 'JMImplementation' is reserved for the JMX Agent"); |
| } |
| |
| MBeanRepository repository = getMBeanRepository(); |
| synchronized (repository) |
| { |
| if (repository.get(objectName) != null) throw new InstanceAlreadyExistsException(objectName.toString()); |
| |
| repository.put(objectName, metadata); |
| } |
| addDomain(objectName.getDomain()); |
| |
| notify(objectName, MBeanServerNotification.REGISTRATION_NOTIFICATION); |
| } |
| |
| private void notify(ObjectName objectName, String notificationType) |
| { |
| long sequenceNumber = 0; |
| synchronized (MX4JMBeanServer.class) |
| { |
| sequenceNumber = notifications; |
| ++notifications; |
| } |
| |
| delegate.sendNotification(new MBeanServerNotification(notificationType, delegateName, sequenceNumber, objectName)); |
| } |
| |
| private void addDomain(String domain) |
| { |
| synchronized (domains) |
| { |
| Integer count = (Integer)domains.get(domain); |
| if (count == null) |
| domains.put(domain, new Integer(1)); |
| else |
| domains.put(domain, new Integer(count.intValue() + 1)); |
| } |
| } |
| |
| private void removeDomain(String domain) |
| { |
| synchronized (domains) |
| { |
| Integer count = (Integer)domains.get(domain); |
| if (count == null) throw new ImplementationException(); |
| if (count.intValue() < 2) |
| domains.remove(domain); |
| else |
| domains.put(domain, new Integer(count.intValue() - 1)); |
| } |
| } |
| |
| public void unregisterMBean(ObjectName objectName) |
| throws InstanceNotFoundException, MBeanRegistrationException |
| { |
| objectName = secureObjectName(objectName); |
| |
| if (objectName == null || objectName.isPattern()) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("ObjectName cannot be null or a pattern ObjectName")); |
| } |
| |
| if (objectName.getDomain().equals("JMImplementation")) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Domain 'JMImplementation' is reserved for the JMX Agent")); |
| } |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| try |
| { |
| MBeanServerInterceptor head = getHeadInterceptor(); |
| head.registration(metadata, MBeanServerInterceptor.PRE_DEREGISTER); |
| |
| unregister(metadata); |
| |
| getHeadInterceptor().registration(metadata, MBeanServerInterceptor.POST_DEREGISTER); |
| |
| if (metadata.mbean instanceof ClassLoader && !(metadata.mbean instanceof PrivateClassLoader)) |
| { |
| getModifiableClassLoaderRepository().removeClassLoader((ClassLoader)metadata.mbean); |
| } |
| } |
| catch (MBeanRegistrationException x) |
| { |
| throw x; |
| } |
| catch (SecurityException x) |
| { |
| throw x; |
| } |
| catch (Exception x) |
| { |
| throw new MBeanRegistrationException(x); |
| } |
| catch (Error x) |
| { |
| throw new MBeanRegistrationException(new RuntimeErrorException(x)); |
| } |
| } |
| |
| private void unregister(MBeanMetaData metadata) |
| { |
| ObjectName objectName = metadata.name; |
| |
| MBeanRepository repository = getMBeanRepository(); |
| synchronized (repository) |
| { |
| repository.remove(objectName); |
| } |
| removeDomain(objectName.getDomain()); |
| |
| notify(objectName, MBeanServerNotification.UNREGISTRATION_NOTIFICATION); |
| } |
| |
| public Object getAttribute(ObjectName objectName, String attribute) |
| throws InstanceNotFoundException, MBeanException, AttributeNotFoundException, ReflectionException |
| { |
| if (attribute == null || attribute.trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid attribute")); |
| } |
| |
| objectName = secureObjectName(objectName); |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| return getHeadInterceptor().getAttribute(metadata, attribute); |
| } |
| |
| |
| public void setAttribute(ObjectName objectName, Attribute attribute) |
| throws InstanceNotFoundException, AttributeNotFoundException, InvalidAttributeValueException, MBeanException, ReflectionException |
| { |
| if (attribute == null || attribute.getName().trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid attribute")); |
| } |
| |
| objectName = secureObjectName(objectName); |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| getHeadInterceptor().setAttribute(metadata, attribute); |
| } |
| |
| public AttributeList getAttributes(ObjectName objectName, String[] attributes) |
| throws InstanceNotFoundException, ReflectionException |
| { |
| if (attributes == null || attributes.length == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid attribute list")); |
| } |
| |
| objectName = secureObjectName(objectName); |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| // Must check if the user has the right to call this method, regardless of the attributes |
| sm.checkPermission(new MBeanPermission(metadata.info.getClassName(), "-", objectName, "getAttribute")); |
| } |
| |
| return getHeadInterceptor().getAttributes(metadata, attributes); |
| } |
| |
| public AttributeList setAttributes(ObjectName objectName, AttributeList attributes) |
| throws InstanceNotFoundException, ReflectionException |
| { |
| if (attributes == null) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid attribute list")); |
| } |
| |
| objectName = secureObjectName(objectName); |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| // Must check if the user has the right to call this method, regardless of the attributes |
| sm.checkPermission(new MBeanPermission(metadata.info.getClassName(), "-", objectName, "setAttribute")); |
| } |
| |
| return getHeadInterceptor().setAttributes(metadata, attributes); |
| } |
| |
| public Object invoke(ObjectName objectName, String methodName, Object[] args, String[] parameters) |
| throws InstanceNotFoundException, MBeanException, ReflectionException |
| { |
| if (methodName == null || methodName.trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid operation name '" + methodName + "'")); |
| } |
| |
| if (args == null) args = EMPTY_ARGS; |
| if (parameters == null) parameters = EMPTY_PARAMS; |
| |
| objectName = secureObjectName(objectName); |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| return getHeadInterceptor().invoke(metadata, methodName, parameters, args); |
| } |
| |
| public String getDefaultDomain() |
| { |
| return defaultDomain; |
| } |
| |
| public String[] getDomains() |
| { |
| synchronized (domains) |
| { |
| Set keys = domains.keySet(); |
| return (String[])keys.toArray(new String[keys.size()]); |
| } |
| } |
| |
| public Integer getMBeanCount() |
| { |
| MBeanRepository repository = getMBeanRepository(); |
| synchronized (repository) |
| { |
| return new Integer(repository.size()); |
| } |
| } |
| |
| public boolean isRegistered(ObjectName objectName) |
| { |
| try |
| { |
| return findMBeanMetaData(objectName) != null; |
| } |
| catch (InstanceNotFoundException x) |
| { |
| return false; |
| } |
| } |
| |
| public MBeanInfo getMBeanInfo(ObjectName objectName) |
| throws InstanceNotFoundException, IntrospectionException, ReflectionException |
| { |
| objectName = secureObjectName(objectName); |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| MBeanInfo info = getHeadInterceptor().getMBeanInfo(metadata); |
| if (info == null) throw new JMRuntimeException("MBeanInfo returned for MBean " + objectName + " is null"); |
| return info; |
| } |
| |
| public ObjectInstance getObjectInstance(ObjectName objectName) |
| throws InstanceNotFoundException |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| objectName = secureObjectName(objectName); |
| } |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| if (sm != null) |
| { |
| sm.checkPermission(new MBeanPermission(metadata.info.getClassName(), "-", objectName, "getObjectInstance")); |
| } |
| |
| return metadata.instance; |
| } |
| |
| public boolean isInstanceOf(ObjectName objectName, String className) |
| throws InstanceNotFoundException |
| { |
| if (className == null || className.trim().length() == 0) |
| { |
| throw new RuntimeOperationsException(new IllegalArgumentException("Invalid class name")); |
| } |
| |
| objectName = secureObjectName(objectName); |
| |
| MBeanMetaData metadata = findMBeanMetaData(objectName); |
| |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| sm.checkPermission(new MBeanPermission(metadata.info.getClassName(), "-", objectName, "isInstanceOf")); |
| } |
| |
| try |
| { |
| ClassLoader loader = metadata.classloader; |
| Class cls = null; |
| if (loader != null) |
| cls = loader.loadClass(className); |
| else |
| cls = Class.forName(className, false, null); |
| |
| if (metadata.mbean instanceof StandardMBean) |
| { |
| Object impl = ((StandardMBean) metadata.mbean).getImplementation(); |
| return cls.isInstance(impl); |
| } |
| else |
| { |
| return cls.isInstance(metadata.mbean); |
| } |
| } |
| catch (ClassNotFoundException x) |
| { |
| return false; |
| } |
| } |
| |
| public Set queryMBeans(ObjectName patternName, QueryExp filter) |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| patternName = secureObjectName(patternName); |
| // Must check if the user has the right to call this method, |
| // no matter which ObjectName has been passed. |
| sm.checkPermission(new MBeanPermission("-#-[-]", "queryMBeans")); |
| } |
| |
| Set match = queryObjectNames(patternName, filter, true); |
| |
| Set set = new HashSet(); |
| for (Iterator i = match.iterator(); i.hasNext();) |
| { |
| ObjectName name = (ObjectName)i.next(); |
| try |
| { |
| MBeanMetaData metadata = findMBeanMetaData(name); |
| set.add(metadata.instance); |
| } |
| catch (InstanceNotFoundException ignored) |
| { |
| // A concurrent thread removed the MBean after queryNames, ignore |
| } |
| } |
| return set; |
| } |
| |
| public Set queryNames(ObjectName patternName, QueryExp filter) |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm != null) |
| { |
| patternName = secureObjectName(patternName); |
| // Must check if the user has the right to call this method, |
| // no matter which ObjectName has been passed. |
| sm.checkPermission(new MBeanPermission("-#-[-]", "queryNames")); |
| } |
| |
| return queryObjectNames(patternName, filter, false); |
| } |
| |
| /** |
| * Utility method for queryNames and queryMBeans that returns a set of ObjectNames. |
| * It does 3 things: |
| * 1) filter the MBeans following the given ObjectName pattern |
| * 2) filter the MBeans following the permissions that client code has |
| * 3) filter the MBeans following the given QueryExp |
| * It is important that these 3 operations are done in this order |
| */ |
| private Set queryObjectNames(ObjectName patternName, QueryExp filter, boolean instances) |
| { |
| // First, retrieve the scope of the query: all mbeans matching the patternName |
| Set scope = findMBeansByPattern(patternName); |
| |
| // Second, filter the scope by checking the caller's permissions |
| Set secureScope = filterMBeansBySecurity(scope, instances); |
| |
| // Third, filter the scope using the given QueryExp |
| Set match = filterMBeansByQuery(secureScope, filter); |
| |
| return match; |
| } |
| |
| /** |
| * Returns a set of ObjectNames of the registered MBeans that match the given ObjectName pattern |
| */ |
| private Set findMBeansByPattern(ObjectName pattern) |
| { |
| if (pattern == null) |
| { |
| try |
| { |
| pattern = new ObjectName("*:*"); |
| } |
| catch (MalformedObjectNameException ignored) |
| { |
| } |
| } |
| |
| pattern = normalizeObjectName(pattern); |
| |
| String patternDomain = pattern.getDomain(); |
| Hashtable patternProps = pattern.getKeyPropertyList(); |
| |
| Set set = new HashSet(); |
| |
| // Clone the repository, we are faster than holding the lock while iterating |
| MBeanRepository repository = (MBeanRepository)getMBeanRepository().clone(); |
| |
| for (Iterator i = repository.iterator(); i.hasNext();) |
| { |
| MBeanMetaData metadata = (MBeanMetaData)i.next(); |
| ObjectName name = metadata.name; |
| Hashtable props = name.getKeyPropertyList(); |
| |
| String domain = name.getDomain(); |
| if (Utils.wildcardMatch(patternDomain, domain)) |
| { |
| // Domain matches, now check properties |
| if (pattern.isPropertyPattern()) |
| { |
| // A property pattern with no entries, can only be '*' |
| if (patternProps.size() == 0) |
| { |
| // User wants all properties |
| set.add(name); |
| } |
| else |
| { |
| // Loop on the properties of the pattern. |
| // If one is not found then the current ObjectName does not match |
| boolean found = true; |
| for (Iterator j = patternProps.entrySet().iterator(); j.hasNext();) |
| { |
| Map.Entry entry = (Map.Entry)j.next(); |
| Object patternKey = entry.getKey(); |
| Object patternValue = entry.getValue(); |
| if (patternKey.equals("*")) |
| { |
| continue; |
| } |
| |
| // Try to see if the current ObjectName contains this entry |
| if (!props.containsKey(patternKey)) |
| { |
| // Not even the key is present |
| found = false; |
| break; |
| } |
| else |
| { |
| // The key is present, let's check if the values are equal |
| Object value = props.get(patternKey); |
| if (value == null && patternValue == null) |
| { |
| // Values are equal, go on with next pattern entry |
| continue; |
| } |
| if (value != null && value.equals(patternValue)) |
| { |
| // Values are equal, go on with next pattern entry |
| continue; |
| } |
| // Here values are different |
| found = false; |
| break; |
| } |
| } |
| if (found) set.add(name); |
| } |
| } |
| else |
| { |
| if (props.entrySet().equals(patternProps.entrySet())) set.add(name); |
| } |
| } |
| } |
| return set; |
| } |
| |
| /** |
| * Filters the given set of ObjectNames following the permission that client code has granted. |
| * Returns a set containing the allowed ObjectNames. |
| */ |
| private Set filterMBeansBySecurity(Set mbeans, boolean instances) |
| { |
| SecurityManager sm = System.getSecurityManager(); |
| if (sm == null) return mbeans; |
| |
| HashSet set = new HashSet(); |
| for (Iterator i = mbeans.iterator(); i.hasNext();) |
| { |
| ObjectName name = (ObjectName)i.next(); |
| try |
| { |
| MBeanMetaData metadata = findMBeanMetaData(name); |
| String className = metadata.info.getClassName(); |
| sm.checkPermission(new MBeanPermission(className, "-", name, instances ? "queryMBeans" : "queryNames")); |
| set.add(name); |
| } |
| catch (InstanceNotFoundException ignored) |
| { |
| // A concurrent thread removed this MBean, continue |
| continue; |
| } |
| catch (SecurityException ignored) |
| { |
| // Don't add the name to the list, and go on. |
| } |
| } |
| return set; |
| } |
| |
| /** |
| * Filters the given set of ObjectNames following the given QueryExp. |
| * Returns a set of ObjectNames that match the given QueryExp. |
| */ |
| private Set filterMBeansByQuery(Set scope, QueryExp filter) |
| { |
| if (filter == null) return scope; |
| |
| Set set = new HashSet(); |
| for (Iterator i = scope.iterator(); i.hasNext();) |
| { |
| ObjectName name = (ObjectName)i.next(); |
| filter.setMBeanServer(this); |
| try |
| { |
| if (filter.apply(name)) set.add(name); |
| } |
| catch (BadStringOperationException ignored) |
| { |
| } |
| catch (BadBinaryOpValueExpException ignored) |
| { |
| } |
| catch (BadAttributeValueExpException x) |
| { |
| } |
| catch (InvalidApplicationException x) |
| { |
| } |
| catch (SecurityException x) |
| { |
| } |
| catch (Exception x) |
| { |
| // The 1.2 spec says Exceptions must not be propagated |
| } |
| } |
| return set; |
| } |
| |
| /** |
| * Returns a normalized ObjectName from the given one. |
| * If an ObjectName is specified with the abbreviated notation for the default domain, that is ':key=value' |
| * this method returns an ObjectName whose domain is the default domain of this MBeanServer and with the same |
| * properties. |
| */ |
| private ObjectName normalizeObjectName(ObjectName name) |
| { |
| if (name == null) return null; |
| |
| String defaultDomain = getDefaultDomain(); |
| String domain = name.getDomain(); |
| |
| if (domain.length() == 0 && defaultDomain.length() > 0) |
| { |
| // The given object name specifies the abbreviated form to indicate the default domain, |
| // ie ':key=value', the empty string as domain. I must convert this abbreviated form |
| // to the full one, if the default domain of this mbeanserver is not the empty string as well |
| StringBuffer buffer = new StringBuffer(defaultDomain).append(":").append(name.getKeyPropertyListString()); |
| if (name.isPropertyPattern()) |
| { |
| if (name.getKeyPropertyList().size() > 0) |
| buffer.append(",*"); |
| else |
| buffer.append("*"); |
| } |
| try |
| { |
| name = new ObjectName(buffer.toString()); |
| } |
| catch (MalformedObjectNameException ignored) |
| { |
| } |
| } |
| return name; |
| } |
| |
| /** |
| * Returns an ObjectName instance even if the provided ObjectName is a subclass. |
| * This is done to avoid security holes: a nasty ObjectName subclass can bypass security checks. |
| */ |
| private ObjectName secureObjectName(ObjectName name) |
| { |
| // I cannot trust ObjectName, since a malicious user can send a subclass that overrides equals and hashcode |
| // to match another ObjectName for which it does not have permission, or returns different results from |
| // ObjectName.getCanonicalName() for different calls, so that passes the security checks but in fact will |
| // later refer to a different ObjectName for which it does not have permission. |
| if (name == null) return null; |
| return ObjectName.getInstance(name); |
| } |
| } |
