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