Subversion Repositories openrisc

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