mirror of git://gcc.gnu.org/git/gcc.git
2234 lines
92 KiB
Java
2234 lines
92 KiB
Java
/* Server.java -- A GNU Classpath management server.
|
|
Copyright (C) 2006 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package gnu.javax.management;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.InputStream;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectStreamClass;
|
|
import java.io.StreamCorruptedException;
|
|
|
|
import java.lang.reflect.Constructor;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import java.util.concurrent.atomic.AtomicLong;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
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.DynamicMBean;
|
|
import javax.management.InstanceAlreadyExistsException;
|
|
import javax.management.InstanceNotFoundException;
|
|
import javax.management.IntrospectionException;
|
|
import javax.management.InvalidApplicationException;
|
|
import javax.management.InvalidAttributeValueException;
|
|
import javax.management.ListenerNotFoundException;
|
|
import javax.management.MalformedObjectNameException;
|
|
import javax.management.MBeanException;
|
|
import javax.management.MBeanInfo;
|
|
import javax.management.MBeanPermission;
|
|
import javax.management.MBeanRegistration;
|
|
import javax.management.MBeanRegistrationException;
|
|
import javax.management.MBeanServer;
|
|
import javax.management.MBeanServerDelegate;
|
|
import javax.management.MBeanServerNotification;
|
|
import javax.management.MBeanTrustPermission;
|
|
import javax.management.NotCompliantMBeanException;
|
|
import javax.management.Notification;
|
|
import javax.management.NotificationBroadcaster;
|
|
import javax.management.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.RuntimeOperationsException;
|
|
import javax.management.StandardMBean;
|
|
|
|
import javax.management.loading.ClassLoaderRepository;
|
|
|
|
/**
|
|
* This class provides an {@link javax.management.MBeanServer}
|
|
* implementation for GNU Classpath.
|
|
*
|
|
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
|
|
* @since 1.5
|
|
*/
|
|
public class Server
|
|
implements MBeanServer
|
|
{
|
|
|
|
/**
|
|
* The name of the delegate bean.
|
|
*/
|
|
private static final ObjectName DELEGATE_NAME;
|
|
|
|
/**
|
|
* The registered beans, represented as a map of
|
|
* {@link javax.management.ObjectName}s to
|
|
* {@link gnu.javax.management.Server.ServerInfo}s.
|
|
*/
|
|
private final ConcurrentHashMap<ObjectName,ServerInfo> beans =
|
|
new ConcurrentHashMap<ObjectName,ServerInfo>();
|
|
|
|
/**
|
|
* The default domain.
|
|
*/
|
|
private final String defaultDomain;
|
|
|
|
/**
|
|
* The outer server.
|
|
*/
|
|
private final MBeanServer outer;
|
|
|
|
/**
|
|
* The class loader repository.
|
|
*/
|
|
private ClassLoaderRepository repository;
|
|
|
|
/**
|
|
* The map of listener delegates to the true
|
|
* listener. We wrap this in an inner class
|
|
* to delay initialisation until a listener
|
|
* is actually added.
|
|
*/
|
|
private static class LazyListenersHolder
|
|
{
|
|
private static final Map<NotificationListener,NotificationListener> listeners =
|
|
new ConcurrentHashMap<NotificationListener,NotificationListener>();
|
|
}
|
|
|
|
/**
|
|
* An MBean that emits notifications when an MBean is registered and
|
|
* unregistered with this server.
|
|
*
|
|
*/
|
|
private final MBeanServerDelegate delegate;
|
|
|
|
/**
|
|
* Provides sequencing for notifications about registrations.
|
|
*/
|
|
private static final AtomicLong sequenceNumber = new AtomicLong(1);
|
|
|
|
/**
|
|
* Initialise the delegate name.
|
|
*/
|
|
static
|
|
{
|
|
try
|
|
{
|
|
DELEGATE_NAME =
|
|
new ObjectName("JMImplementation:type=MBeanServerDelegate");
|
|
}
|
|
catch (MalformedObjectNameException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to construct " +
|
|
"the delegate's object name.").initCause(e));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Constructs a new management server using the specified
|
|
* default domain, delegate bean and outer server.
|
|
*
|
|
* @param defaultDomain the default domain to use for beans constructed
|
|
* with no specified domain.
|
|
* @param outer an {@link javax.management.MBeanServer} to pass
|
|
* to beans implementing the {@link MBeanRegistration}
|
|
* interface, or <code>null</code> if <code>this</code>
|
|
* should be passed.
|
|
* @param delegate the delegate bean for this server.
|
|
*/
|
|
public Server(String defaultDomain, MBeanServer outer,
|
|
MBeanServerDelegate delegate)
|
|
{
|
|
this.defaultDomain = defaultDomain;
|
|
this.outer = outer;
|
|
this.delegate = delegate;
|
|
try
|
|
{
|
|
registerMBean(delegate, DELEGATE_NAME);
|
|
}
|
|
catch (InstanceAlreadyExistsException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("The delegate bean is " +
|
|
"already registered.").initCause(e));
|
|
}
|
|
catch (MBeanRegistrationException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("The delegate bean's preRegister " +
|
|
"methods threw an exception.").initCause(e));
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("The delegate bean is " +
|
|
"not compliant.").initCause(e));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks for the necessary security privileges to perform an
|
|
* operation.
|
|
*
|
|
* @param name the name of the bean being accessed.
|
|
* @param member the name of the operation or attribute being
|
|
* accessed, or <code>null</code> if one is not
|
|
* involved.
|
|
* @param action the action being performed.
|
|
* @throws SecurityException if the action is denied.
|
|
*/
|
|
private void checkSecurity(ObjectName name, String member,
|
|
String action)
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null)
|
|
try
|
|
{
|
|
MBeanInfo info = null;
|
|
if (name != null)
|
|
{
|
|
Object bean = getBean(name);
|
|
Method method = bean.getClass().getMethod("getMBeanInfo");
|
|
info = (MBeanInfo) method.invoke(bean);
|
|
}
|
|
sm.checkPermission(new MBeanPermission((info == null) ?
|
|
null : info.getClassName(),
|
|
member, name, action));
|
|
}
|
|
catch (InstanceNotFoundException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to get bean.").initCause(e));
|
|
}
|
|
catch (NoSuchMethodException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to get bean info.").initCause(e));
|
|
}
|
|
catch (IllegalAccessException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to get bean info.").initCause(e));
|
|
}
|
|
catch (IllegalArgumentException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to get bean info.").initCause(e));
|
|
}
|
|
catch (InvocationTargetException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to get bean info.").initCause(e));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retrieves the specified bean.
|
|
*
|
|
* @param name the name of the bean.
|
|
* @return the bean.
|
|
* @throws InstanceNotFoundException if the name of the management bean
|
|
* could not be resolved.
|
|
*/
|
|
private Object getBean(ObjectName name)
|
|
throws InstanceNotFoundException
|
|
{
|
|
ServerInfo bean = beans.get(name);
|
|
if (bean == null)
|
|
throw new InstanceNotFoundException("The bean, " + name +
|
|
", was not found.");
|
|
return bean.getObject();
|
|
}
|
|
|
|
/**
|
|
* Registers the supplied listener with the specified management
|
|
* bean. Notifications emitted by the management bean are forwarded
|
|
* to the listener via the server, which will convert an MBean
|
|
* references in the source to a portable {@link ObjectName}
|
|
* instance. The notification is otherwise unchanged.
|
|
*
|
|
* @param name the name of the management bean with which the listener
|
|
* should be registered.
|
|
* @param listener the listener which will handle notifications from
|
|
* the bean.
|
|
* @param filter the filter to apply to incoming notifications, or
|
|
* <code>null</code> if no filtering should be applied.
|
|
* @param passback an object to be passed to the listener when a
|
|
* notification is emitted.
|
|
* @throws InstanceNotFoundException if the name of the management bean
|
|
* could not be resolved.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "addNotificationListener")</code>}.
|
|
* @see #removeNotificationListener(ObjectName, NotificationListener)
|
|
* @see #removeNotificationListener(ObjectName, NotificationListener,
|
|
* NotificationFilter, Object)
|
|
* @see NotificationBroadcaster#addNotificationListener(NotificationListener,
|
|
* NotificationFilter,
|
|
* Object)
|
|
*/
|
|
public void addNotificationListener(ObjectName name, NotificationListener listener,
|
|
NotificationFilter filter, Object passback)
|
|
throws InstanceNotFoundException
|
|
{
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "addNotificationListener");
|
|
if (bean instanceof NotificationBroadcaster)
|
|
{
|
|
NotificationBroadcaster bbean = (NotificationBroadcaster) bean;
|
|
NotificationListener indirection = new ServerNotificationListener(bean, name,
|
|
listener);
|
|
bbean.addNotificationListener(indirection, filter, passback);
|
|
LazyListenersHolder.listeners.put(listener, indirection);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Registers the supplied listener with the specified management
|
|
* bean. Notifications emitted by the management bean are forwarded
|
|
* to the listener via the server, which will convert any MBean
|
|
* references in the source to portable {@link ObjectName}
|
|
* instances. The notification is otherwise unchanged.
|
|
* </p>
|
|
* <p>
|
|
* The listener that receives notifications will be the one that is
|
|
* registered with the given name at the time this method is called.
|
|
* Even if it later unregisters and ceases to use that name, it will
|
|
* still receive notifications.
|
|
* </p>
|
|
*
|
|
* @param name the name of the management bean with which the listener
|
|
* should be registered.
|
|
* @param listener the name of the listener which will handle
|
|
* notifications from the bean.
|
|
* @param filter the filter to apply to incoming notifications, or
|
|
* <code>null</code> if no filtering should be applied.
|
|
* @param passback an object to be passed to the listener when a
|
|
* notification is emitted.
|
|
* @throws InstanceNotFoundException if the name of the management bean
|
|
* could not be resolved.
|
|
* @throws RuntimeOperationsException if the bean associated with the given
|
|
* object name is not a
|
|
* {@link NotificationListener}. This
|
|
* exception wraps an
|
|
* {@link IllegalArgumentException}.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "addNotificationListener")</code>}.
|
|
* @see #removeNotificationListener(ObjectName, NotificationListener)
|
|
* @see #removeNotificationListener(ObjectName, NotificationListener,
|
|
* NotificationFilter, Object)
|
|
* @see NotificationBroadcaster#addNotificationListener(NotificationListener,
|
|
* NotificationFilter,
|
|
* Object)
|
|
*/
|
|
public void addNotificationListener(ObjectName name, ObjectName listener,
|
|
NotificationFilter filter, Object passback)
|
|
throws InstanceNotFoundException
|
|
{
|
|
Object lbean = getBean(listener);
|
|
if (!(lbean instanceof NotificationListener))
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The supplied listener name does not " +
|
|
"correspond to a notification listener.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
addNotificationListener(name, ((NotificationListener) lbean), filter, passback);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Instantiates a new instance of the specified management bean
|
|
* using the default constructor and registers it with the server
|
|
* under the supplied name. The class is loaded using the
|
|
* {@link javax.management.loading.ClassLoaderRepository default
|
|
* loader repository} of the server.
|
|
* </p>
|
|
* <p>
|
|
* If the name supplied is <code>null</code>, then the bean is
|
|
* expected to implement the {@link MBeanRegistration} interface.
|
|
* The {@link MBeanRegistration#preRegister preRegister} method
|
|
* of this interface will be used to obtain the name in this case.
|
|
* </p>
|
|
* <p>
|
|
* This method is equivalent to calling {@link
|
|
* #createMBean(String, ObjectName, Object[], String[])
|
|
* <code>createMBean(className, name, (Object[]) null,
|
|
* (String[]) null)</code>} with <code>null</code> parameters
|
|
* and signature.
|
|
* </p>
|
|
*
|
|
* @param className the class of the management bean, of which
|
|
* an instance should be created.
|
|
* @param name the name to register the new bean with.
|
|
* @return an {@link ObjectInstance} containing the {@link ObjectName}
|
|
* and Java class name of the created instance.
|
|
* @throws ReflectionException if an exception occurs in creating
|
|
* an instance of the bean.
|
|
* @throws InstanceAlreadyExistsException if a matching instance
|
|
* already exists.
|
|
* @throws MBeanRegistrationException if an exception occurs in
|
|
* calling the preRegister
|
|
* method.
|
|
* @throws MBeanException if the bean's constructor throws an exception.
|
|
* @throws NotCompliantMBeanException if the created bean is not
|
|
* compliant with the JMX specification.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> class name or object
|
|
* name or if the object name is a pattern.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply the
|
|
* use of the <code>instantiate</code>
|
|
* and <code>registerMBean</code> methods.
|
|
* @see #createMBean(String, ObjectName, Object[], String[])
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name)
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException
|
|
{
|
|
return createMBean(className, name, (Object[]) null, (String[]) null);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Instantiates a new instance of the specified management bean
|
|
* using the given constructor and registers it with the server
|
|
* under the supplied name. The class is loaded using the
|
|
* {@link javax.management.loading.ClassLoaderRepository default
|
|
* loader repository} of the server.
|
|
* </p>
|
|
* <p>
|
|
* If the name supplied is <code>null</code>, then the bean is
|
|
* expected to implement the {@link MBeanRegistration} interface.
|
|
* The {@link MBeanRegistration#preRegister preRegister} method
|
|
* of this interface will be used to obtain the name in this case.
|
|
* </p>
|
|
*
|
|
* @param className the class of the management bean, of which
|
|
* an instance should be created.
|
|
* @param name the name to register the new bean with.
|
|
* @param params the parameters for the bean's constructor.
|
|
* @param sig the signature of the constructor to use.
|
|
* @return an {@link ObjectInstance} containing the {@link ObjectName}
|
|
* and Java class name of the created instance.
|
|
* @throws ReflectionException if an exception occurs in creating
|
|
* an instance of the bean.
|
|
* @throws InstanceAlreadyExistsException if a matching instance
|
|
* already exists.
|
|
* @throws MBeanRegistrationException if an exception occurs in
|
|
* calling the preRegister
|
|
* method.
|
|
* @throws MBeanException if the bean's constructor throws an exception.
|
|
* @throws NotCompliantMBeanException if the created bean is not
|
|
* compliant with the JMX specification.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> class name or object
|
|
* name or if the object name is a pattern.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply the
|
|
* use of the <code>instantiate</code>
|
|
* and <code>registerMBean</code> methods.
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
Object[] params, String[] sig)
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException
|
|
{
|
|
return registerMBean(instantiate(className, params, sig), name);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Instantiates a new instance of the specified management bean
|
|
* using the default constructor and registers it with the server
|
|
* under the supplied name. The class is loaded using the
|
|
* given class loader. If this argument is <code>null</code>,
|
|
* then the same class loader as was used to load the server
|
|
* is used.
|
|
* </p>
|
|
* <p>
|
|
* If the name supplied is <code>null</code>, then the bean is
|
|
* expected to implement the {@link MBeanRegistration} interface.
|
|
* The {@link MBeanRegistration#preRegister preRegister} method
|
|
* of this interface will be used to obtain the name in this case.
|
|
* </p>
|
|
* <p>
|
|
* This method is equivalent to calling {@link
|
|
* #createMBean(String, ObjectName, ObjectName, Object[], String)
|
|
* <code>createMBean(className, name, loaderName, (Object[]) null,
|
|
* (String) null)</code>} with <code>null</code> parameters
|
|
* and signature.
|
|
* </p>
|
|
*
|
|
* @param className the class of the management bean, of which
|
|
* an instance should be created.
|
|
* @param name the name to register the new bean with.
|
|
* @param loaderName the name of the class loader.
|
|
* @return an {@link ObjectInstance} containing the {@link ObjectName}
|
|
* and Java class name of the created instance.
|
|
* @throws ReflectionException if an exception occurs in creating
|
|
* an instance of the bean.
|
|
* @throws InstanceAlreadyExistsException if a matching instance
|
|
* already exists.
|
|
* @throws MBeanRegistrationException if an exception occurs in
|
|
* calling the preRegister
|
|
* method.
|
|
* @throws MBeanException if the bean's constructor throws an exception.
|
|
* @throws NotCompliantMBeanException if the created bean is not
|
|
* compliant with the JMX specification.
|
|
* @throws InstanceNotFoundException if the specified class loader is not
|
|
* registered with the server.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> class name or object
|
|
* name or if the object name is a pattern.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply the
|
|
* use of the <code>instantiate</code>
|
|
* and <code>registerMBean</code> methods.
|
|
* @see #createMBean(String, ObjectName, ObjectName, Object[], String[])
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
ObjectName loaderName)
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException, InstanceNotFoundException
|
|
{
|
|
return createMBean(className, name, loaderName, (Object[]) null,
|
|
(String[]) null);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Instantiates a new instance of the specified management bean
|
|
* using the given constructor and registers it with the server
|
|
* under the supplied name. The class is loaded using the
|
|
* given class loader. If this argument is <code>null</code>,
|
|
* then the same class loader as was used to load the server
|
|
* is used.
|
|
* </p>
|
|
* <p>
|
|
* If the name supplied is <code>null</code>, then the bean is
|
|
* expected to implement the {@link MBeanRegistration} interface.
|
|
* The {@link MBeanRegistration#preRegister preRegister} method
|
|
* of this interface will be used to obtain the name in this case.
|
|
* </p>
|
|
*
|
|
* @param className the class of the management bean, of which
|
|
* an instance should be created.
|
|
* @param name the name to register the new bean with.
|
|
* @param loaderName the name of the class loader.
|
|
* @param params the parameters for the bean's constructor.
|
|
* @param sig the signature of the constructor to use.
|
|
* @return an {@link ObjectInstance} containing the {@link ObjectName}
|
|
* and Java class name of the created instance.
|
|
* @throws ReflectionException if an exception occurs in creating
|
|
* an instance of the bean.
|
|
* @throws InstanceAlreadyExistsException if a matching instance
|
|
* already exists.
|
|
* @throws MBeanRegistrationException if an exception occurs in
|
|
* calling the preRegister
|
|
* method.
|
|
* @throws MBeanException if the bean's constructor throws an exception.
|
|
* @throws NotCompliantMBeanException if the created bean is not
|
|
* compliant with the JMX specification.
|
|
* @throws InstanceNotFoundException if the specified class loader is not
|
|
* registered with the server.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> class name or object
|
|
* name or if the object name is a pattern.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply the
|
|
* use of the <code>instantiate</code>
|
|
* and <code>registerMBean</code> methods.
|
|
*/
|
|
public ObjectInstance createMBean(String className, ObjectName name,
|
|
ObjectName loaderName, Object[] params,
|
|
String[] sig)
|
|
throws ReflectionException, InstanceAlreadyExistsException,
|
|
MBeanRegistrationException, MBeanException,
|
|
NotCompliantMBeanException, InstanceNotFoundException
|
|
{
|
|
return registerMBean(instantiate(className, loaderName, params, sig),
|
|
name);
|
|
}
|
|
|
|
/**
|
|
* Deserializes a byte array using the class loader of the specified
|
|
* management bean as its context.
|
|
*
|
|
* @param name the name of the bean whose class loader should be used.
|
|
* @param data the byte array to be deserialized.
|
|
* @return the deserialized object stream.
|
|
* @deprecated {@link #getClassLoaderFor(ObjectName)} should be used
|
|
* to obtain the class loader of the bean, which can then
|
|
* be used to perform deserialization in the user's code.
|
|
* @throws InstanceNotFoundException if the specified bean is not
|
|
* registered with the server.
|
|
* @throws OperationsException if any I/O error is thrown by the
|
|
* deserialization process.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "getClassLoaderFor")</code>
|
|
*/
|
|
public ObjectInputStream deserialize(ObjectName name, byte[] data)
|
|
throws InstanceNotFoundException, OperationsException
|
|
{
|
|
try
|
|
{
|
|
return new ServerInputStream(new ByteArrayInputStream(data),
|
|
getClassLoaderFor(name));
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
throw new OperationsException("An I/O error occurred: " + e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deserializes a byte array using the same class loader for its context
|
|
* as was used to load the given class. This class loader is obtained by
|
|
* loading the specified class using the {@link
|
|
* javax.management.loading.ClassLoaderRepository Class Loader Repository}
|
|
* and then using the class loader of the resulting {@link Class} instance.
|
|
*
|
|
* @param name the name of the class which should be loaded to obtain the
|
|
* class loader.
|
|
* @param data the byte array to be deserialized.
|
|
* @return the deserialized object stream.
|
|
* @deprecated {@link #getClassLoaderRepository} should be used
|
|
* to obtain the class loading repository, which can then
|
|
* be used to obtain the {@link Class} instance and deserialize
|
|
* the array using its class loader.
|
|
* @throws OperationsException if any I/O error is thrown by the
|
|
* deserialization process.
|
|
* @throws ReflectionException if an error occurs in obtaining the
|
|
* {@link Class} instance.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(null, null, null,
|
|
* "getClassLoaderRepository")</code>
|
|
*/
|
|
public ObjectInputStream deserialize(String name, byte[] data)
|
|
throws OperationsException, ReflectionException
|
|
{
|
|
try
|
|
{
|
|
Class<?> c = getClassLoaderRepository().loadClass(name);
|
|
return new ServerInputStream(new ByteArrayInputStream(data),
|
|
c.getClassLoader());
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
throw new OperationsException("An I/O error occurred: " + e);
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
throw new ReflectionException(e, "The class could not be found.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deserializes a byte array using the same class loader for its context
|
|
* as was used to load the given class. The name of the class loader to
|
|
* be used is supplied, and may be <code>null</code> if the server's
|
|
* class loader should be used instead.
|
|
*
|
|
* @param name the name of the class which should be loaded to obtain the
|
|
* class loader.
|
|
* @param loader the name of the class loader to use, or <code>null</code>
|
|
* if the class loader of the server should be used.
|
|
* @param data the byte array to be deserialized.
|
|
* @return the deserialized object stream.
|
|
* @deprecated {@link #getClassLoader(ObjectName} can be used to obtain
|
|
* the named class loader and deserialize the array.
|
|
* @throws InstanceNotFoundException if the specified class loader is not
|
|
* registered with the server.
|
|
* @throws OperationsException if any I/O error is thrown by the
|
|
* deserialization process.
|
|
* @throws ReflectionException if an error occurs in obtaining the
|
|
* {@link Class} instance.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, loader,
|
|
* "getClassLoader")</code>
|
|
*/
|
|
public ObjectInputStream deserialize(String name, ObjectName loader, byte[] data)
|
|
throws InstanceNotFoundException, ReflectionException,
|
|
OperationsException
|
|
{
|
|
try
|
|
{
|
|
Class<?> c = getClassLoader(loader).loadClass(name);
|
|
return new ServerInputStream(new ByteArrayInputStream(data),
|
|
c.getClassLoader());
|
|
}
|
|
catch (IOException e)
|
|
{
|
|
throw new OperationsException("An I/O error occurred: " + e);
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
throw new ReflectionException(e, "The class could not be found.");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the value of the supplied attribute from the specified
|
|
* management bean.
|
|
*
|
|
* @param bean the bean to retrieve the value from.
|
|
* @param name the name of the attribute to retrieve.
|
|
* @return the value of the attribute.
|
|
* @throws AttributeNotFoundException if the attribute could not be
|
|
* accessed from the bean.
|
|
* @throws MBeanException if the management bean's accessor throws
|
|
* an exception.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws ReflectionException if an exception was thrown in trying
|
|
* to invoke the bean's accessor.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> bean or attribute
|
|
* name.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, name, bean,
|
|
* "getAttribute")</code>}.
|
|
* @see DynamicMBean#getAttribute(String)
|
|
*/
|
|
public Object getAttribute(ObjectName bean, String name)
|
|
throws MBeanException, AttributeNotFoundException,
|
|
InstanceNotFoundException, ReflectionException
|
|
{
|
|
if (bean == null || name == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("One of the supplied arguments was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
Object abean = getBean(bean);
|
|
checkSecurity(bean, name, "getAttribute");
|
|
if (abean instanceof DynamicMBean)
|
|
return ((DynamicMBean) abean).getAttribute(name);
|
|
else
|
|
try
|
|
{
|
|
return new StandardMBean(abean, null).getAttribute(name);
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to create dynamic bean.").initCause(e));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the values of the named attributes from the specified
|
|
* management bean.
|
|
*
|
|
* @param bean the bean to retrieve the value from.
|
|
* @param names the names of the attributes to retrieve.
|
|
* @return the values of the attributes.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws ReflectionException if an exception was thrown in trying
|
|
* to invoke the bean's accessor.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> bean or attribute
|
|
* name.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, bean,
|
|
* "getAttribute")</code>}. Additionally,
|
|
* for an attribute name, <code>n</code>, the
|
|
* caller's permission must imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, n, bean,
|
|
* "getAttribute")</code>} or that attribute will
|
|
* not be included.
|
|
*
|
|
* @see DynamicMBean#getAttributes(String[])
|
|
*/
|
|
public AttributeList getAttributes(ObjectName bean, String[] names)
|
|
throws InstanceNotFoundException, ReflectionException
|
|
{
|
|
if (bean == null || names == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("One of the supplied arguments was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
Object abean = getBean(bean);
|
|
checkSecurity(bean, null, "getAttribute");
|
|
AttributeList list = new AttributeList(names.length);
|
|
for (int a = 0; a < names.length; ++a)
|
|
{
|
|
if (names[a] == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("Argument " + a + " was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
checkSecurity(bean, names[a], "getAttribute");
|
|
try
|
|
{
|
|
Object value;
|
|
if (abean instanceof DynamicMBean)
|
|
value = ((DynamicMBean) abean).getAttribute(names[a]);
|
|
else
|
|
try
|
|
{
|
|
value = new StandardMBean(abean, null).getAttribute(names[a]);
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to create dynamic bean.").initCause(e));
|
|
}
|
|
list.add(new Attribute(names[a], value));
|
|
}
|
|
catch (AttributeNotFoundException e)
|
|
{
|
|
/* Ignored */
|
|
}
|
|
catch (MBeanException e)
|
|
{
|
|
/* Ignored */
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the specified class loader. If the specified value is
|
|
* <code>null</code>, then the class loader of the server will be
|
|
* returned. If <code>l</code> is the requested class loader,
|
|
* and <code>r</code> is the actual class loader returned, then
|
|
* either <code>l</code> and <code>r</code> will be identical,
|
|
* or they will at least return the same class from
|
|
* {@link ClassLoader#loadClass(String)} for any given string.
|
|
* They may not be identical due to one or the other
|
|
* being wrapped in another class loader (e.g. for security).
|
|
*
|
|
* @param name the name of the class loader to return.
|
|
* @return the class loader.
|
|
* @throws InstanceNotFoundException if the class loader can not
|
|
* be found.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "getClassLoader")</code>
|
|
*/
|
|
public ClassLoader getClassLoader(ObjectName name)
|
|
throws InstanceNotFoundException
|
|
{
|
|
if (name == null)
|
|
{
|
|
checkSecurity(null, null, "getClassLoader");
|
|
return getClass().getClassLoader();
|
|
}
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "getClassLoader");
|
|
return (ClassLoader) bean;
|
|
}
|
|
|
|
/**
|
|
* Returns the class loader of the specified management bean. If
|
|
* <code>l</code> is the requested class loader, and <code>r</code>
|
|
* is the actual class loader returned, then either <code>l</code>
|
|
* and <code>r</code> will be identical, or they will at least
|
|
* return the same class from {@link ClassLoader#loadClass(String)}
|
|
* for any given string. They may not be identical due to one or
|
|
* the other being wrapped in another class loader (e.g. for
|
|
* security).
|
|
*
|
|
* @param name the name of the bean whose class loader should be
|
|
* returned.
|
|
* @return the class loader.
|
|
* @throws InstanceNotFoundException if the bean is not registered
|
|
* with the server.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "getClassLoaderFor")</code>
|
|
*/
|
|
public ClassLoader getClassLoaderFor(ObjectName name)
|
|
throws InstanceNotFoundException
|
|
{
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "getClassLoaderFor");
|
|
return bean.getClass().getClassLoader();
|
|
}
|
|
|
|
/**
|
|
* Returns the class loader repository used by this server.
|
|
*
|
|
* @return the class loader repository.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(null, null, null,
|
|
* "getClassLoaderRepository")</code>
|
|
*/
|
|
public ClassLoaderRepository getClassLoaderRepository()
|
|
{
|
|
return repository;
|
|
}
|
|
|
|
/**
|
|
* Returns the default domain this server applies to beans that have
|
|
* no specified domain.
|
|
*
|
|
* @return the default domain.
|
|
*/
|
|
public String getDefaultDomain()
|
|
{
|
|
return defaultDomain;
|
|
}
|
|
|
|
/**
|
|
* Returns an array containing all the domains used by beans registered
|
|
* with this server. The ordering of the array is undefined.
|
|
*
|
|
* @return the list of domains.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(null, null, name,
|
|
* "getDomains")</code>}. Additionally,
|
|
* for an domain, <code>d</code>, the
|
|
* caller's permission must imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(null, null,
|
|
* new ObjectName("d:x=x"), "getDomains")</code>}
|
|
* or that domain will not be included. Note
|
|
* that "x=x" is an arbitrary key-value pair
|
|
* provided to satisfy the constructor.
|
|
* @see ObjectName#getDomain()
|
|
*/
|
|
public String[] getDomains()
|
|
{
|
|
checkSecurity(null, null, "getDomains");
|
|
Set<String> domains = new HashSet<String>();
|
|
Iterator<ObjectName> iterator = beans.keySet().iterator();
|
|
while (iterator.hasNext())
|
|
{
|
|
String d = iterator.next().getDomain();
|
|
try
|
|
{
|
|
checkSecurity(new ObjectName(d + ":x=x"), null, "getDomains");
|
|
domains.add(d);
|
|
}
|
|
catch (MalformedObjectNameException e)
|
|
{
|
|
/* Ignored */
|
|
}
|
|
}
|
|
return domains.toArray(new String[domains.size()]);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of management beans registered with this server.
|
|
* This may be less than the real number if the caller's access is
|
|
* restricted.
|
|
*
|
|
* @return the number of registered beans.
|
|
*/
|
|
public Integer getMBeanCount()
|
|
{
|
|
return Integer.valueOf(beans.size());
|
|
}
|
|
|
|
/**
|
|
* Returns information on the given management bean.
|
|
*
|
|
* @param name the name of the management bean.
|
|
* @return an instance of {@link MBeanInfo} for the bean.
|
|
* @throws IntrospectionException if an exception occurs in examining
|
|
* the bean.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws ReflectionException if an exception occurs when trying
|
|
* to invoke {@link DynamicMBean#getMBeanInfo()}
|
|
* on the bean.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "getMBeanInfo")</code>}.
|
|
* @see DynamicMBean#getMBeanInfo()
|
|
*/
|
|
public MBeanInfo getMBeanInfo(ObjectName name)
|
|
throws InstanceNotFoundException, IntrospectionException,
|
|
ReflectionException
|
|
{
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "getMBeanInfo");
|
|
try
|
|
{
|
|
Method method = bean.getClass().getMethod("getMBeanInfo");
|
|
return (MBeanInfo) method.invoke(bean);
|
|
}
|
|
catch (NoSuchMethodException e)
|
|
{
|
|
try
|
|
{
|
|
return new StandardMBean(bean, null).getMBeanInfo();
|
|
}
|
|
catch (NotCompliantMBeanException ex)
|
|
{
|
|
throw new IntrospectionException("An error occurred in executing " +
|
|
"getMBeanInfo on the bean: " + ex + ".");
|
|
}
|
|
}
|
|
catch (IllegalAccessException e)
|
|
{
|
|
throw new ReflectionException(e, "Failed to call getMBeanInfo");
|
|
}
|
|
catch (IllegalArgumentException e)
|
|
{
|
|
throw new ReflectionException(e, "Failed to call getMBeanInfo");
|
|
}
|
|
catch (InvocationTargetException e)
|
|
{
|
|
throw new ReflectionException(e, "The method threw an exception");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the {@link ObjectInstance} created for the specified
|
|
* management bean on registration.
|
|
*
|
|
* @param name the name of the bean.
|
|
* @return the corresponding {@link ObjectInstance} instance.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "getObjectInstance")</code>
|
|
* @see #createMBean(String, ObjectName)
|
|
*/
|
|
public ObjectInstance getObjectInstance(ObjectName name)
|
|
throws InstanceNotFoundException
|
|
{
|
|
ServerInfo bean = beans.get(name);
|
|
if (bean == null)
|
|
throw new InstanceNotFoundException("The bean, " + name +
|
|
", was not found.");
|
|
return bean.getInstance();
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Creates an instance of the specified class using the list of
|
|
* class loaders from the {@link
|
|
* javax.management.loading.ClassLoaderRepository Class Loader
|
|
* Repository}. The class should have a public constructor
|
|
* with no arguments. A reference to the new instance is returned,
|
|
* but the instance is not yet registered with the server.
|
|
* </p>
|
|
* <p>
|
|
* This method is equivalent to calling {@link
|
|
* #instantiate(String, Object[], String[])
|
|
* <code>instantiate(name, (Object[]) null, (String[]) null)</code>}
|
|
* with <code>null</code> parameters and signature.
|
|
* </p>
|
|
*
|
|
* @param name the name of the class of bean to be instantiated.
|
|
* @return an instance of the given class.
|
|
* @throws ReflectionException if an exception is thrown during
|
|
* loading the class or calling the
|
|
* constructor.
|
|
* @throws MBeanException if the constructor throws an exception.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> name.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, null,
|
|
* "instantiate")</code>}.
|
|
* @see #instantiate(String, Object[], String[])
|
|
*/
|
|
public Object instantiate(String name)
|
|
throws ReflectionException, MBeanException
|
|
{
|
|
return instantiate(name, (Object[]) null, (String[]) null);
|
|
}
|
|
|
|
/**
|
|
* Creates an instance of the specified class using the list of
|
|
* class loaders from the {@link
|
|
* javax.management.loading.ClassLoaderRepository Class Loader
|
|
* Repository}. The class should have a public constructor
|
|
* matching the supplied signature. A reference to the new
|
|
* instance is returned, but the instance is not yet
|
|
* registered with the server.
|
|
*
|
|
* @param name the name of the class of bean to be instantiated.
|
|
* @param params the parameters for the constructor.
|
|
* @param sig the signature of the constructor.
|
|
* @return an instance of the given class.
|
|
* @throws ReflectionException if an exception is thrown during
|
|
* loading the class or calling the
|
|
* constructor.
|
|
* @throws MBeanException if the constructor throws an exception.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> name.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, null,
|
|
* "instantiate")</code>}.
|
|
*/
|
|
public Object instantiate(String name, Object[] params, String[] sig)
|
|
throws ReflectionException, MBeanException
|
|
{
|
|
checkSecurity(null, null, "instantiate");
|
|
if (name == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The name was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
Class<?>[] sigTypes = new Class[sig.length];
|
|
for (int a = 0; a < sigTypes.length; ++a)
|
|
{
|
|
try
|
|
{
|
|
sigTypes[a] = repository.loadClass(sig[a]);
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
throw new ReflectionException(e, "The class, " + sigTypes[a] +
|
|
", in the method signature " +
|
|
"could not be loaded.");
|
|
}
|
|
}
|
|
try
|
|
{
|
|
Constructor<?> cons =
|
|
repository.loadClass(name).getConstructor(sigTypes);
|
|
return cons.newInstance(params);
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
throw new ReflectionException(e, "The class, " + name +
|
|
", of the constructor " +
|
|
"could not be loaded.");
|
|
}
|
|
catch (NoSuchMethodException e)
|
|
{
|
|
throw new ReflectionException(e, "The method, " + name +
|
|
", could not be found.");
|
|
}
|
|
catch (IllegalAccessException e)
|
|
{
|
|
throw new ReflectionException(e, "Failed to instantiate the object");
|
|
}
|
|
catch (InstantiationException e)
|
|
{
|
|
throw new ReflectionException(e, "Failed to instantiate the object");
|
|
}
|
|
catch (InvocationTargetException e)
|
|
{
|
|
throw new MBeanException((Exception) e.getCause(), "The constructor "
|
|
+ name + " threw an exception");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Creates an instance of the specified class using the supplied
|
|
* class loader. If the class loader given is <code>null</code>,
|
|
* then the class loader of the server will be used. The class
|
|
* should have a public constructor with no arguments. A reference
|
|
* to the new instance is returned, but the instance is not yet
|
|
* registered with the server.
|
|
* </p>
|
|
* <p>
|
|
* This method is equivalent to calling {@link
|
|
* #instantiate(String, ObjectName, Object[], String[])
|
|
* <code>instantiate(name, loaderName, (Object[]) null,
|
|
* (String[]) null)</code>} with <code>null</code> parameters
|
|
* and signature.
|
|
* </p>
|
|
*
|
|
* @param name the name of the class of bean to be instantiated.
|
|
* @param loaderName the name of the class loader to use.
|
|
* @return an instance of the given class.
|
|
* @throws InstanceNotFoundException if the class loader is not
|
|
* registered with the server.
|
|
* @throws ReflectionException if an exception is thrown during
|
|
* loading the class or calling the
|
|
* constructor.
|
|
* @throws MBeanException if the constructor throws an exception.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> name.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, null,
|
|
* "instantiate")</code>}.
|
|
* @see #instantiate(String, Object[], String[])
|
|
*/
|
|
public Object instantiate(String name, ObjectName loaderName)
|
|
throws InstanceNotFoundException, ReflectionException,
|
|
MBeanException
|
|
{
|
|
return instantiate(name, loaderName);
|
|
}
|
|
|
|
/**
|
|
* Creates an instance of the specified class using the supplied
|
|
* class loader. If the class loader given is <code>null</code>,
|
|
* then the class loader of the server will be used. The class
|
|
* should have a public constructor matching the supplied
|
|
* signature. A reference to the new instance is returned,
|
|
* but the instance is not yet registered with the server.
|
|
*
|
|
* @param name the name of the class of bean to be instantiated.
|
|
* @param loaderName the name of the class loader to use.
|
|
* @param params the parameters for the constructor.
|
|
* @param sig the signature of the constructor.
|
|
* @return an instance of the given class.
|
|
* @throws InstanceNotFoundException if the class loader is not
|
|
* registered with the server.
|
|
* @throws ReflectionException if an exception is thrown during
|
|
* loading the class or calling the
|
|
* constructor.
|
|
* @throws MBeanException if the constructor throws an exception.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> name.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, null,
|
|
* "instantiate")</code>}.
|
|
*/
|
|
public Object instantiate(String name, ObjectName loaderName,
|
|
Object[] params, String[] sig)
|
|
throws InstanceNotFoundException, ReflectionException,
|
|
MBeanException
|
|
{
|
|
checkSecurity(null, null, "instantiate");
|
|
if (name == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The name was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
ClassLoader loader = getClassLoader(loaderName);
|
|
Class<?>[] sigTypes = new Class[sig.length];
|
|
for (int a = 0; a < sig.length; ++a)
|
|
{
|
|
try
|
|
{
|
|
sigTypes[a] = Class.forName(sig[a], true, loader);
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
throw new ReflectionException(e, "The class, " + sig[a] +
|
|
", in the method signature " +
|
|
"could not be loaded.");
|
|
}
|
|
}
|
|
try
|
|
{
|
|
Constructor<?> cons =
|
|
Class.forName(name, true, loader).getConstructor(sigTypes);
|
|
return cons.newInstance(params);
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
throw new ReflectionException(e, "The class, " + name +
|
|
", of the constructor " +
|
|
"could not be loaded.");
|
|
}
|
|
catch (NoSuchMethodException e)
|
|
{
|
|
throw new ReflectionException(e, "The method, " + name +
|
|
", could not be found.");
|
|
}
|
|
catch (IllegalAccessException e)
|
|
{
|
|
throw new ReflectionException(e, "Failed to instantiate the object");
|
|
}
|
|
catch (InstantiationException e)
|
|
{
|
|
throw new ReflectionException(e, "Failed to instantiate the object");
|
|
}
|
|
catch (InvocationTargetException e)
|
|
{
|
|
throw new MBeanException((Exception) e.getCause(), "The constructor "
|
|
+ name + " threw an exception");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invokes the supplied operation on the specified management
|
|
* bean. The class objects specified in the signature are loaded
|
|
* using the same class loader as was used for the management bean.
|
|
*
|
|
* @param bean the management bean whose operation should be invoked.
|
|
* @param name the name of the operation to invoke.
|
|
* @param params the parameters of the operation.
|
|
* @param sig the signature of the operation.
|
|
* @return the return value of the method.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws MBeanException if the method invoked throws an exception.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> name.
|
|
* @throws ReflectionException if an exception is thrown in invoking the
|
|
* method.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, name, bean,
|
|
* "invoke")</code>}.
|
|
* @see DynamicMBean#invoke(String, Object[], String[])
|
|
*/
|
|
public Object invoke(ObjectName bean, String name, Object[] params, String[] sig)
|
|
throws InstanceNotFoundException, MBeanException,
|
|
ReflectionException
|
|
{
|
|
if (bean == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The bean was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
Object abean = getBean(bean);
|
|
checkSecurity(bean, name, "invoke");
|
|
if (abean instanceof DynamicMBean)
|
|
return ((DynamicMBean) abean).invoke(name, params, sig);
|
|
else
|
|
try
|
|
{
|
|
return new StandardMBean(abean, null).invoke(name, params, sig);
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to create dynamic bean.").initCause(e));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Returns true if the specified management bean is an instance
|
|
* of the supplied class.
|
|
* </p>
|
|
* <p>
|
|
* A bean, B, is an instance of a class, C, if either of the following
|
|
* conditions holds:
|
|
* </p>
|
|
* <ul>
|
|
* <li>The class name in B's {@link MBeanInfo} is equal to the supplied
|
|
* name.</li>
|
|
* <li>Both the class of B and C were loaded by the same class loader,
|
|
* and B is assignable to C.</li>
|
|
* </ul>
|
|
*
|
|
* @param name the name of the management bean.
|
|
* @param className the name of the class to test if <code>name</code> is
|
|
* an instance of.
|
|
* @return true if either B is directly an instance of the named class,
|
|
* or B is assignable to the class, given that both it and B's
|
|
* current class were loaded using the same class loader.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "isInstanceOf")</code>
|
|
*/
|
|
public boolean isInstanceOf(ObjectName name, String className)
|
|
throws InstanceNotFoundException
|
|
{
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "isInstanceOf");
|
|
MBeanInfo info;
|
|
if (bean instanceof DynamicMBean)
|
|
info = ((DynamicMBean) bean).getMBeanInfo();
|
|
else
|
|
try
|
|
{
|
|
info = new StandardMBean(bean, null).getMBeanInfo();
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to create dynamic bean.").initCause(e));
|
|
}
|
|
if (info.getClassName().equals(className))
|
|
return true;
|
|
Class<?> bclass = bean.getClass();
|
|
try
|
|
{
|
|
Class<?> oclass = Class.forName(className);
|
|
return (bclass.getClassLoader().equals(oclass.getClassLoader()) &&
|
|
oclass.isAssignableFrom(bclass));
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the specified management bean is registered with
|
|
* the server.
|
|
*
|
|
* @param name the name of the management bean.
|
|
* @return true if the bean is registered.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> bean name.
|
|
*/
|
|
public boolean isRegistered(ObjectName name)
|
|
{
|
|
if (name == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The name was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
return beans.containsKey(name);
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Returns a set of {@link ObjectInstance}s matching the specified
|
|
* criteria. The full set of beans registered with the server
|
|
* are passed through two filters:
|
|
* </p>
|
|
* <ol>
|
|
* <li>Pattern matching is performed using the supplied
|
|
* {@link ObjectName}.</li>
|
|
* <li>The supplied query expression is applied.</li>
|
|
* </ol>
|
|
* <p>
|
|
* If both the object name and the query expression are <code>null</code>,
|
|
* or the object name has no domain and no key properties,
|
|
* no filtering will be performed and all beans are returned.
|
|
* </p>
|
|
*
|
|
* @param name an {@link ObjectName} to use as a filter.
|
|
* @param query a query expression to apply to each of the beans that match
|
|
* the given object name.
|
|
* @return a set of {@link ObjectInstance}s matching the filtered beans.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(null, null, name,
|
|
* "queryMBeans")</code>}. Additionally,
|
|
* for an bean, <code>b</code>, the
|
|
* caller's permission must imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, b, name,
|
|
* "queryMBeans")</code>} or that bean will
|
|
* not be included. Such an exception may also
|
|
* arise from the execution of the query, in which
|
|
* case that particular bean will again be excluded.
|
|
*/
|
|
public Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query)
|
|
{
|
|
checkSecurity(name, null, "queryMBeans");
|
|
Set<ObjectInstance> results = new HashSet<ObjectInstance>();
|
|
for (Map.Entry<ObjectName,ServerInfo> entry : beans.entrySet())
|
|
{
|
|
ObjectName nextName = entry.getKey();
|
|
checkSecurity(name, nextName.toString(), "queryMBeans");
|
|
try
|
|
{
|
|
if ((name == null || name.apply(nextName)) &&
|
|
(query == null || query.apply(nextName)))
|
|
results.add(entry.getValue().getInstance());
|
|
}
|
|
catch (BadStringOperationException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
catch (BadBinaryOpValueExpException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
catch (BadAttributeValueExpException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
catch (InvalidApplicationException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* <p>
|
|
* Returns a set of {@link ObjectName}s matching the specified
|
|
* criteria. The full set of beans registered with the server
|
|
* are passed through two filters:
|
|
* </p>
|
|
* <ol>
|
|
* <li>Pattern matching is performed using the supplied
|
|
* {@link ObjectName}.</li>
|
|
* <li>The supplied query expression is applied.</li>
|
|
* </ol>
|
|
* <p>
|
|
* If both the object name and the query expression are <code>null</code>,
|
|
* or the object name has no domain and no key properties,
|
|
* no filtering will be performed and all beans are returned.
|
|
* </p>
|
|
*
|
|
* @param name an {@link ObjectName} to use as a filter.
|
|
* @param query a query expression to apply to each of the beans that match
|
|
* the given object name.
|
|
* @return a set of {@link ObjectName}s matching the filtered beans.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(null, null, name,
|
|
* "queryNames")</code>}. Additionally,
|
|
* for an name, <code>n</code>, the
|
|
* caller's permission must imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, n, name,
|
|
* "queryNames")</code>} or that name will
|
|
* not be included. Such an exception may also
|
|
* arise from the execution of the query, in which
|
|
* case that particular bean will again be excluded.
|
|
* Note that these permissions are implied if the
|
|
* <code>queryMBeans</code> permissions are available.
|
|
*/
|
|
public Set<ObjectName> queryNames(ObjectName name, QueryExp query)
|
|
{
|
|
checkSecurity(name, null, "queryNames");
|
|
Set<ObjectName> results = new HashSet<ObjectName>();
|
|
for (ObjectName nextName : beans.keySet())
|
|
{
|
|
checkSecurity(name, nextName.toString(), "queryNames");
|
|
try
|
|
{
|
|
if ((name == null || name.apply(nextName)) &&
|
|
(query == null || query.apply(nextName)))
|
|
results.add(nextName);
|
|
}
|
|
catch (BadStringOperationException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
catch (BadBinaryOpValueExpException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
catch (BadAttributeValueExpException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
catch (InvalidApplicationException e)
|
|
{
|
|
/* Ignored -- assume false result */
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
|
|
/**
|
|
* Registers the supplied instance with the server, using the specified
|
|
* {@link ObjectName}. If the name given is <code>null</code>, then
|
|
* the bean supplied is expected to implement the {@link MBeanRegistration}
|
|
* interface and provide the name via the
|
|
* {@link MBeanRegistration#preRegister preRegister} method
|
|
* of this interface.
|
|
*
|
|
* @param obj the object to register with the server.
|
|
* @param name the name under which to register the object,
|
|
* or <code>null</code> if the {@link MBeanRegistration}
|
|
* interface should be used.
|
|
* @return an {@link ObjectInstance} containing the supplied
|
|
* {@link ObjectName} along with the name of the bean's class.
|
|
* @throws InstanceAlreadyExistsException if a matching instance
|
|
* already exists.
|
|
* @throws MBeanRegistrationException if an exception occurs in
|
|
* calling the preRegister
|
|
* method.
|
|
* @throws NotCompliantMBeanException if the created bean is not
|
|
* compliant with the JMX specification.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> object.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "registerMBean")</code>}. <code>className</code>
|
|
* here corresponds to the result of
|
|
* {@link MBeanInfo#getClassName()} for objects of
|
|
* this class. If this check succeeds, a check
|
|
* is also made on its
|
|
* {@link java.security.ProtectionDomain} to ensure
|
|
* it implies {@link MBeanTrustPermission(String)
|
|
* <code>MBeanTrustPermission("register")</code>}.
|
|
* The use of the {@link MBeanRegistration} interface
|
|
* results in another {@link MBeanPermission} check
|
|
* being made on the returned {@link ObjectName}.
|
|
*/
|
|
public ObjectInstance registerMBean(Object obj, ObjectName name)
|
|
throws InstanceAlreadyExistsException, MBeanRegistrationException,
|
|
NotCompliantMBeanException
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
Class<?> cl = obj.getClass();
|
|
String className = cl.getName();
|
|
if (sm != null)
|
|
{
|
|
sm.checkPermission(new MBeanPermission(className, null, name,
|
|
"registerMBean"));
|
|
if (!(cl.getProtectionDomain().implies(new MBeanTrustPermission("register"))))
|
|
throw new SecurityException("The protection domain of the object's class" +
|
|
"does not imply the trust permission," +
|
|
"register");
|
|
}
|
|
if (obj == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The object was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
MBeanRegistration register = null;
|
|
if (obj instanceof MBeanRegistration)
|
|
register = (MBeanRegistration) obj;
|
|
if (name == null && register == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The name was null and " +
|
|
"the bean does not implement " +
|
|
"MBeanRegistration.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
if (register != null)
|
|
{
|
|
try
|
|
{
|
|
name = register.preRegister(this, name);
|
|
if (name == null)
|
|
{
|
|
RuntimeException e =
|
|
new NullPointerException("The name returned by " +
|
|
"MBeanRegistration.preRegister() " +
|
|
"was null");
|
|
throw e;
|
|
}
|
|
if (sm != null)
|
|
sm.checkPermission(new MBeanPermission(className, null, name,
|
|
"registerMBean"));
|
|
}
|
|
catch (SecurityException e)
|
|
{
|
|
register.postRegister(Boolean.FALSE);
|
|
throw e;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
register.postRegister(Boolean.FALSE);
|
|
throw new MBeanRegistrationException(e, "Pre-registration failed.");
|
|
}
|
|
}
|
|
ObjectInstance obji = new ObjectInstance(name, className);
|
|
if (beans.putIfAbsent(name, new ServerInfo(obji, obj)) != null)
|
|
{
|
|
if (register != null)
|
|
register.postRegister(Boolean.FALSE);
|
|
throw new InstanceAlreadyExistsException(name + "is already registered.");
|
|
}
|
|
if (register != null)
|
|
register.postRegister(Boolean.TRUE);
|
|
notify(name, MBeanServerNotification.REGISTRATION_NOTIFICATION);
|
|
return obji;
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener from the list of recipients
|
|
* of notifications from the supplied bean. This includes all
|
|
* combinations of filters and passback objects registered for
|
|
* this listener. For more specific removal of listeners, see
|
|
* {@link #removeNotificationListener(ObjectName,
|
|
* NotificationListener,NotificationFilter,Object)}
|
|
*
|
|
* @param name the name of the management bean from which the
|
|
* listener should be removed.
|
|
* @param listener the listener to remove.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws ListenerNotFoundException if the specified listener
|
|
* is not registered with the bean.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "removeNotificationListener")</code>}.
|
|
* @see #addNotificationListener(NotificationListener, NotificationFilter,
|
|
* java.lang.Object)
|
|
* @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name,
|
|
NotificationListener listener)
|
|
throws InstanceNotFoundException, ListenerNotFoundException
|
|
{
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "removeNotificationListener");
|
|
if (bean instanceof NotificationBroadcaster)
|
|
{
|
|
NotificationBroadcaster bbean = (NotificationBroadcaster) bean;
|
|
bbean.removeNotificationListener(listener);
|
|
LazyListenersHolder.listeners.remove(listener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener from the list of recipients
|
|
* of notifications from the supplied bean. Only the first instance with
|
|
* the supplied filter and passback object is removed.
|
|
* <code>null</code> is used as a valid value for these parameters,
|
|
* rather than as a way to remove all registration instances for
|
|
* the specified listener; for this behaviour instead, see
|
|
* {@link #removeNotificationListener(ObjectName, NotificationListener)}.
|
|
*
|
|
* @param name the name of the management bean from which the
|
|
* listener should be removed.
|
|
* @param listener the listener to remove.
|
|
* @param filter the filter of the listener to remove.
|
|
* @param passback the passback object of the listener to remove.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws ListenerNotFoundException if the specified listener
|
|
* is not registered with the bean.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "removeNotificationListener")</code>}.
|
|
* @see #addNotificationListener(ObjectName, NotificationListener,
|
|
* NotificationFilter, Object)
|
|
* @see NotificationEmitter#removeNotificationListener(NotificationListener,
|
|
* NotificationFilter,
|
|
* Object)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name,
|
|
NotificationListener listener,
|
|
NotificationFilter filter,
|
|
Object passback)
|
|
throws InstanceNotFoundException, ListenerNotFoundException
|
|
{
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "removeNotificationListener");
|
|
if (bean instanceof NotificationEmitter)
|
|
{
|
|
NotificationEmitter bbean = (NotificationEmitter) bean;
|
|
bbean.removeNotificationListener(listener, filter, passback);
|
|
LazyListenersHolder.listeners.remove(listener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener from the list of recipients
|
|
* of notifications from the supplied bean. This includes all
|
|
* combinations of filters and passback objects registered for
|
|
* this listener. For more specific removal of listeners, see
|
|
* {@link #removeNotificationListener(ObjectName,
|
|
* ObjectName,NotificationFilter,Object)}
|
|
*
|
|
* @param name the name of the management bean from which the
|
|
* listener should be removed.
|
|
* @param listener the name of the listener to remove.
|
|
* @throws InstanceNotFoundException if a name doesn't match a registered
|
|
* bean.
|
|
* @throws ListenerNotFoundException if the specified listener
|
|
* is not registered with the bean.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "removeNotificationListener")</code>}.
|
|
* @see #addNotificationListener(NotificationListener, NotificationFilter,
|
|
* java.lang.Object)
|
|
* @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name, ObjectName listener)
|
|
throws InstanceNotFoundException, ListenerNotFoundException
|
|
{
|
|
Object lbean = getBean(listener);
|
|
if (!(lbean instanceof NotificationListener))
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The supplied listener name does not " +
|
|
"correspond to a notification listener.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
removeNotificationListener(name, ((NotificationListener) lbean));
|
|
}
|
|
|
|
/**
|
|
* Removes the specified listener from the list of recipients
|
|
* of notifications from the supplied bean. Only the first instance with
|
|
* the supplied filter and passback object is removed.
|
|
* <code>null</code> is used as a valid value for these parameters,
|
|
* rather than as a way to remove all registration instances for
|
|
* the specified listener; for this behaviour instead, see
|
|
* {@link #removeNotificationListener(ObjectName, ObjectName)}.
|
|
*
|
|
* @param name the name of the management bean from which the
|
|
* listener should be removed.
|
|
* @param listener the name of the listener to remove.
|
|
* @param filter the filter of the listener to remove.
|
|
* @param passback the passback object of the listener to remove.
|
|
* @throws InstanceNotFoundException if a name doesn't match a registered
|
|
* bean.
|
|
* @throws ListenerNotFoundException if the specified listener
|
|
* is not registered with the bean.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "removeNotificationListener")</code>}.
|
|
* @see #addNotificationListener(ObjectName, NotificationListener,
|
|
* NotificationFilter, Object)
|
|
* @see NotificationEmitter#removeNotificationListener(NotificationListener,
|
|
* NotificationFilter,
|
|
* Object)
|
|
*/
|
|
public void removeNotificationListener(ObjectName name,
|
|
ObjectName listener,
|
|
NotificationFilter filter,
|
|
Object passback)
|
|
throws InstanceNotFoundException, ListenerNotFoundException
|
|
{
|
|
Object lbean = getBean(listener);
|
|
if (!(lbean instanceof NotificationListener))
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The supplied listener name does not " +
|
|
"correspond to a notification listener.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
removeNotificationListener(name, ((NotificationListener) lbean), filter,
|
|
passback);
|
|
}
|
|
|
|
/**
|
|
* Sets the value of the specified attribute of the supplied
|
|
* management bean.
|
|
*
|
|
* @param name the name of the management bean.
|
|
* @param attribute the attribute to set.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws AttributeNotFoundException if the attribute does not
|
|
* correspond to an attribute
|
|
* of the bean.
|
|
* @throws InvalidAttributeValueException if the value is invalid
|
|
* for this particular
|
|
* attribute of the bean.
|
|
* @throws MBeanException if setting the attribute causes
|
|
* the bean to throw an exception (which
|
|
* becomes the cause of this exception).
|
|
* @throws ReflectionException if an exception occurred in trying
|
|
* to use the reflection interface
|
|
* to lookup the attribute. The
|
|
* thrown exception is the cause of
|
|
* this exception.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> bean or attribute
|
|
* name.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, name, bean,
|
|
* "setAttribute")</code>}.
|
|
* @see #getAttribute(ObjectName, String)
|
|
* @see DynamicMBean#setAttribute(Attribute)
|
|
*/
|
|
public void setAttribute(ObjectName name, Attribute attribute)
|
|
throws InstanceNotFoundException, AttributeNotFoundException,
|
|
InvalidAttributeValueException, MBeanException,
|
|
ReflectionException
|
|
{
|
|
if (attribute == null || name == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("One of the supplied arguments was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, attribute.getName(), "setAttribute");
|
|
if (bean instanceof DynamicMBean)
|
|
((DynamicMBean) bean).setAttribute(attribute);
|
|
else
|
|
try
|
|
{
|
|
new StandardMBean(bean, null).setAttribute(attribute);
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to create dynamic bean.").initCause(e));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the value of each of the specified attributes
|
|
* of the supplied management bean to that specified by
|
|
* the {@link Attribute} object. The returned list contains
|
|
* the attributes that were set and their new values.
|
|
*
|
|
* @param name the name of the management bean.
|
|
* @param attributes the attributes to set.
|
|
* @return a list of the changed attributes.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws ReflectionException if an exception occurred in trying
|
|
* to use the reflection interface
|
|
* to lookup the attribute. The
|
|
* thrown exception is the cause of
|
|
* this exception.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> bean or attribute
|
|
* list.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, bean,
|
|
* "setAttribute")</code>}. Additionally,
|
|
* for an attribute name, <code>n</code>, the
|
|
* caller's permission must imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, n, bean,
|
|
* "setAttribute")</code>} or that attribute will
|
|
* not be included.
|
|
* @see #getAttributes(ObjectName, String[])
|
|
* @see DynamicMBean#setAttributes(AttributeList)
|
|
*/
|
|
public AttributeList setAttributes(ObjectName name, AttributeList attributes)
|
|
throws InstanceNotFoundException, ReflectionException
|
|
{
|
|
if (name == null || attributes == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("One of the supplied arguments was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
Object abean = getBean(name);
|
|
checkSecurity(name, null, "setAttribute");
|
|
AttributeList list = new AttributeList(attributes.size());
|
|
Iterator<Object> it = attributes.iterator();
|
|
while (it.hasNext())
|
|
{
|
|
try
|
|
{
|
|
Attribute attrib = (Attribute) it.next();
|
|
if (attrib == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("An attribute was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
checkSecurity(name, attrib.getName(), "setAttribute");
|
|
if (abean instanceof DynamicMBean)
|
|
((DynamicMBean) abean).setAttribute(attrib);
|
|
else
|
|
try
|
|
{
|
|
new StandardMBean(abean, null).setAttribute(attrib);
|
|
}
|
|
catch (NotCompliantMBeanException e)
|
|
{
|
|
throw (Error)
|
|
(new InternalError("Failed to create dynamic bean.").initCause(e));
|
|
}
|
|
list.add(attrib);
|
|
}
|
|
catch (AttributeNotFoundException e)
|
|
{
|
|
/* Ignored */
|
|
}
|
|
catch (InvalidAttributeValueException e)
|
|
{
|
|
/* Ignored */
|
|
}
|
|
catch (MBeanException e)
|
|
{
|
|
/* Ignored */
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
/**
|
|
* Unregisters the specified management bean. Following this operation,
|
|
* the bean instance is no longer accessible from the server via this
|
|
* name. Prior to unregistering the bean, the
|
|
* {@link MBeanRegistration#preDeregister()} method will be called if
|
|
* the bean implements the {@link MBeanRegistration} interface.
|
|
*
|
|
* @param name the name of the management bean.
|
|
* @throws InstanceNotFoundException if the bean can not be found.
|
|
* @throws MBeanRegistrationException if an exception occurs in
|
|
* calling the preDeregister
|
|
* method.
|
|
* @throws RuntimeOperationsException if an {@link IllegalArgumentException}
|
|
* is thrown by the server due to a
|
|
* <code>null</code> bean name or a
|
|
* request being made to unregister the
|
|
* {@link MBeanServerDelegate} bean.
|
|
* @throws SecurityException if a security manager exists and the
|
|
* caller's permissions don't imply {@link
|
|
* MBeanPermission(String,String,ObjectName,String)
|
|
* <code>MBeanPermission(className, null, name,
|
|
* "unregisterMBean")</code>}.
|
|
*/
|
|
public void unregisterMBean(ObjectName name)
|
|
throws InstanceNotFoundException, MBeanRegistrationException
|
|
{
|
|
if (name == null)
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The name was null.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
if (name.equals(DELEGATE_NAME))
|
|
{
|
|
RuntimeException e =
|
|
new IllegalArgumentException("The delegate can not be unregistered.");
|
|
throw new RuntimeOperationsException(e);
|
|
}
|
|
Object bean = getBean(name);
|
|
checkSecurity(name, null, "unregisterMBean");
|
|
MBeanRegistration register = null;
|
|
if (bean instanceof MBeanRegistration)
|
|
{
|
|
register = (MBeanRegistration) bean;
|
|
try
|
|
{
|
|
register.preDeregister();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
throw new MBeanRegistrationException(e, "Pre-deregistration failed.");
|
|
}
|
|
}
|
|
beans.remove(name);
|
|
notify(name, MBeanServerNotification.UNREGISTRATION_NOTIFICATION);
|
|
if (register != null)
|
|
register.postDeregister();
|
|
}
|
|
|
|
/**
|
|
* Notifies the delegate of beans being registered
|
|
* and unregistered.
|
|
*
|
|
* @param name the bean being registered.
|
|
* @param type the type of notification;
|
|
* {@code REGISTRATION_NOTIFICATION} or
|
|
* {@code UNREGISTRATION_NOTIFICATION}.
|
|
*/
|
|
private void notify(ObjectName name, String type)
|
|
{
|
|
delegate.sendNotification
|
|
(new MBeanServerNotification
|
|
(type, DELEGATE_NAME, sequenceNumber.getAndIncrement(), name));
|
|
}
|
|
|
|
/**
|
|
* Input stream which deserializes using the given classloader.
|
|
*/
|
|
private class ServerInputStream
|
|
extends ObjectInputStream
|
|
{
|
|
|
|
private ClassLoader cl;
|
|
|
|
public ServerInputStream(InputStream is, ClassLoader cl)
|
|
throws IOException, StreamCorruptedException
|
|
{
|
|
super(is);
|
|
this.cl = cl;
|
|
}
|
|
|
|
protected Class<?> resolveClass(ObjectStreamClass osc)
|
|
throws ClassNotFoundException, IOException
|
|
{
|
|
try
|
|
{
|
|
return Class.forName(osc.getName(), true, cl);
|
|
}
|
|
catch (ClassNotFoundException e)
|
|
{
|
|
return super.resolveClass(osc);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Holder for information on registered beans.
|
|
*/
|
|
private class ServerInfo
|
|
{
|
|
private ObjectInstance instance;
|
|
|
|
private Object object;
|
|
|
|
public ServerInfo(ObjectInstance instance, Object object)
|
|
{
|
|
this.instance = instance;
|
|
this.object = object;
|
|
}
|
|
|
|
public Object getObject()
|
|
{
|
|
return object;
|
|
}
|
|
|
|
public ObjectInstance getInstance()
|
|
{
|
|
return instance;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Notification listener which removes direct references
|
|
* to beans.
|
|
*/
|
|
private class ServerNotificationListener
|
|
implements NotificationListener
|
|
{
|
|
|
|
/**
|
|
* The bean from which notifications are emitted.
|
|
*/
|
|
Object bean;
|
|
|
|
/**
|
|
* The {@link ObjectName} of the emitting bean.
|
|
*/
|
|
ObjectName name;
|
|
|
|
/**
|
|
* The real {@link NotificationListener}.
|
|
*/
|
|
NotificationListener listener;
|
|
|
|
/**
|
|
* Constructs a new {@link ServerNotificationListener} replacing
|
|
* occurrences of <code>bean</code> with its name.
|
|
*
|
|
* @param bean the bean emitting notifications.
|
|
* @param name the object name of the emitting bean.
|
|
* @param listener the listener events eventually reach.
|
|
*/
|
|
public ServerNotificationListener(Object bean, ObjectName name,
|
|
NotificationListener listener)
|
|
{
|
|
this.bean = bean;
|
|
this.name = name;
|
|
this.listener = listener;
|
|
}
|
|
|
|
/**
|
|
* Replace a direct reference to <code>bean</code> with its
|
|
* object reference, if necessary, before calling the listener.
|
|
*
|
|
* @param notif the notification being emitted.
|
|
* @param handback an object that will be returned to the notification
|
|
* listener when an event occurs.
|
|
*/
|
|
public void handleNotification(Notification notif, Object handback)
|
|
{
|
|
if (notif.getSource() == bean)
|
|
notif.setSource(name);
|
|
listener.handleNotification(notif, handback);
|
|
}
|
|
|
|
}
|
|
|
|
}
|