/*

 * Copyright 2002-2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package javax.management;

import com.sun.jmx.mbeanserver.DescriptorCache;

import com.sun.jmx.mbeanserver.Introspector;

import com.sun.jmx.mbeanserver.MBeanInjector;

import com.sun.jmx.mbeanserver.MBeanSupport;

import com.sun.jmx.mbeanserver.MXBeanSupport;

import com.sun.jmx.mbeanserver.StandardMBeanSupport;

import com.sun.jmx.mbeanserver.Util;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.HashMap;

import java.util.Map;

import java.util.WeakHashMap;

import java.util.logging.Level;

import javax.management.openmbean.MXBeanMappingFactory;

import javax.management.openmbean.OpenMBeanAttributeInfo;

import javax.management.openmbean.OpenMBeanAttributeInfoSupport;

import javax.management.openmbean.OpenMBeanConstructorInfo;

import javax.management.openmbean.OpenMBeanConstructorInfoSupport;

import javax.management.openmbean.OpenMBeanOperationInfo;

import javax.management.openmbean.OpenMBeanOperationInfoSupport;

import javax.management.openmbean.OpenMBeanParameterInfo;

import javax.management.openmbean.OpenMBeanParameterInfoSupport;

import static com.sun.jmx.defaults.JmxProperties.MISC_LOGGER;

import static javax.management.JMX.MBeanOptions;

/**

 * <p>An MBean whose management interface is determined by reflection

 * on a Java interface.</p>

 *

 * <p>This class brings more flexibility to the notion of Management

 * Interface in the use of Standard MBeans.  Straightforward use of

 * the patterns for Standard MBeans described in the JMX Specification

 * means that there is a fixed relationship between the implementation

 * class of an MBean and its management interface (i.e., if the

 * implementation class is Thing, the management interface must be

 * ThingMBean).  This class makes it possible to keep the convenience

 * of specifying the management interface with a Java interface,

 * without requiring that there be any naming relationship between the

 * implementation and interface classes.</p>

 *

 * <p>By making a DynamicMBean out of an MBean, this class makes

 * it possible to select any interface implemented by the MBean as its

 * management interface, provided that it complies with JMX patterns

 * (i.e., attributes defined by getter/setter etc...).</p>

 *

 * <p> This class also provides hooks that make it possible to supply

 * custom descriptions and names for the {@link MBeanInfo} returned by

 * the DynamicMBean interface.</p>

 *

 * <p>Using this class, an MBean can be created with any

 * implementation class name <i>Impl</i> and with a management

 * interface defined (as for current Standard MBeans) by any interface

 * <i>Intf</i>, in one of two general ways:</p>

 *

 * <ul>

 *

 * <li>Using the public constructor

 *     {@link #StandardMBean(java.lang.Object, java.lang.Class, boolean)

 *     StandardMBean(impl,interface)}:

 *     <pre>

 *     MBeanServer mbs;

 *     ...

 *     Impl impl = new Impl(...);

 *     StandardMBean mbean = new StandardMBean(impl, Intf.class, false);

 *     mbs.registerMBean(mbean, objectName);

 *     </pre></li>

 *

 * <li>Subclassing StandardMBean:

 *     <pre>

 *     public class Impl extends StandardMBean implements Intf {

 *        public Impl() {

 *          super(Intf.class, false);

 *       }

 *       // implement methods of Intf

 *     }

 *

 *     [...]

 *

 *     MBeanServer mbs;

 *     ....

 *     Impl impl = new Impl();

 *     mbs.registerMBean(impl, objectName);

 *     </pre></li>

 *

 * </ul>

 *

 * <p>In either case, the class <i>Impl</i> must implement the

 * interface <i>Intf</i>.</p>

 *

 * <p>Standard MBeans based on the naming relationship between

 * implementation and interface classes are of course still

 * available.</p>

 *

 * <p>This class may also be used to construct MXBeans.  The usage

 * is exactly the same as for Standard MBeans except that in the

 * examples above, the {@code false} parameter to the constructor or

 * {@code super(...)} invocation is instead {@code true}.</p>

 *

 * @since 1.5

 */

public class StandardMBean implements DynamicWrapperMBean, MBeanRegistration {

    /**

     * <p>Options controlling the behavior of {@code StandardMBean} instances.</p>

     */

    public static class Options extends JMX.MBeanOptions {

        private static final long serialVersionUID = 5107355471177517164L;

        private boolean wrappedVisible;

        /**

         * <p>Construct an {@code Options} object where all options have

         * their default values.</p>

         */

        public Options() {}

        @Override

        public Options clone() {

            return (Options) super.clone();

        }

        /**

         * <p>Defines whether the {@link StandardMBean#getWrappedObject()

         * getWrappedObject} method returns the wrapped object.</p>

         *

         * <p>If this option is true, then {@code getWrappedObject()} will return

         * the same object as {@link StandardMBean#getImplementation()

         * getImplementation}.  Otherwise, it will return the

         * StandardMBean instance itself.  The setting of this option

         * affects the behavior of {@link MBeanServer#getClassLoaderFor

         * MBeanServer.getClassLoaderFor} and {@link MBeanServer#isInstanceOf

         * MBeanServer.isInstanceOf}.  The default value is false for

         * compatibility reasons, but true is a better value for most new code.</p>

         *

         * @return true if this StandardMBean's {@link

         * StandardMBean#getWrappedObject getWrappedObject} returns the wrapped

         * object.

         */

        public boolean isWrappedObjectVisible() {

            return this.wrappedVisible;

        }

        /**

         * <p>Set the {@link #isWrappedObjectVisible WrappedObjectVisible} option

         * to the given value.</p>

         * @param visible the new value.

         */

        public void setWrappedObjectVisible(boolean visible) {

            this.wrappedVisible = visible;

        }

        // Canonical objects for each of (MXBean,!MXBean) x (WVisible,!WVisible)

        private static final Options[] CANONICALS = {

            new Options(), new Options(), new Options(), new Options(),

        };

        static {

            CANONICALS[1].setMXBeanMappingFactory(MXBeanMappingFactory.DEFAULT);

            CANONICALS[2].setWrappedObjectVisible(true);

            CANONICALS[3].setMXBeanMappingFactory(MXBeanMappingFactory.DEFAULT);

            CANONICALS[3].setWrappedObjectVisible(true);

        }

        @Override

        MBeanOptions[] canonicals() {

            return CANONICALS;

        }

        @Override

        boolean same(MBeanOptions opts) {

            return (super.same(opts) && opts instanceof Options &&

                    ((Options) opts).wrappedVisible == wrappedVisible);

        }

    }

    private final static DescriptorCache descriptors =

        DescriptorCache.getInstance(JMX.proof);

    /**

     * The DynamicMBean that wraps the MXBean or Standard MBean implementation.

     **/

    private volatile MBeanSupport<?> mbean;

    /**

     * The cached MBeanInfo.

     **/

    private volatile MBeanInfo cachedMBeanInfo;

    /**

     * The MBeanOptions for this StandardMBean.

     **/

    private MBeanOptions options;

    /**

     * Make a DynamicMBean out of <var>implementation</var>, using the

     * specified <var>mbeanInterface</var> class.

     * @param implementation The implementation of this MBean.

     *        If <code>null</code>, and null implementation is allowed,

     *        then the implementation is assumed to be <var>this</var>.

     * @param mbeanInterface The Management Interface exported by this

     *        MBean's implementation. If <code>null</code>, then this

     *        object will use standard JMX design pattern to determine

     *        the management interface associated with the given

     *        implementation.

     * @param nullImplementationAllowed <code>true</code> if a null

     *        implementation is allowed. If null implementation is allowed,

     *        and a null implementation is passed, then the implementation

     *        is assumed to be <var>this</var>.

     * @param options MBeanOptions to apply to this instance.

     * @exception IllegalArgumentException if the given

     *    <var>implementation</var> is null, and null is not allowed.

     **/

    @SuppressWarnings("unchecked")  // cast to T

    private <T> void construct(T implementation, Class<T> mbeanInterface,

                               boolean nullImplementationAllowed,

                               MBeanOptions options)

                               throws NotCompliantMBeanException {

        if (implementation == null) {

            // Have to use (T)this rather than mbeanInterface.cast(this)

            // because mbeanInterface might be null.

            if (nullImplementationAllowed)

                implementation = Util.<T>cast(this);

            else throw new IllegalArgumentException("implementation is null");

        }

        if (options == null)

            options = new MBeanOptions();

        MXBeanMappingFactory mappingFactory = options.getMXBeanMappingFactory();

        boolean mx = (mappingFactory != null);

        if (mbeanInterface == null) {

            mbeanInterface = Util.cast(Introspector.getStandardOrMXBeanInterface(

                                       implementation.getClass(), mx));

        }

        if (mx) {

            this.mbean =

                    new MXBeanSupport(implementation, mbeanInterface,

                                      mappingFactory);

        } else {

            this.mbean =

                    new StandardMBeanSupport(implementation, mbeanInterface);

        }

        this.options = options.canonical();

    }

    /**

     * <p>Make a DynamicMBean out of the object

     * <var>implementation</var>, using the specified

     * <var>mbeanInterface</var> class.</p>

     *

     * @param implementation The implementation of this MBean.

     * @param mbeanInterface The Management Interface exported by this

     *        MBean's implementation. If <code>null</code>, then this

     *        object will use standard JMX design pattern to determine

     *        the management interface associated with the given

     *        implementation.

     * @param <T> Allows the compiler to check

     * that {@code implementation} does indeed implement the class

     * described by {@code mbeanInterface}.  The compiler can only

     * check this if {@code mbeanInterface} is a class literal such

     * as {@code MyMBean.class}.

     *

     * @exception IllegalArgumentException if the given

     *    <var>implementation</var> is null.

     * @exception NotCompliantMBeanException if the <var>mbeanInterface</var>

     *    does not follow JMX design patterns for Management Interfaces, or

     *    if the given <var>implementation</var> does not implement the

     *    specified interface.

     **/

    public <T> StandardMBean(T implementation, Class<T> mbeanInterface)

        throws NotCompliantMBeanException {

        construct(implementation, mbeanInterface, false, null);

    }

    /**

     * <p>Make a DynamicMBean out of <var>this</var>, using the specified

     * <var>mbeanInterface</var> class.</p>

     *

     * <p>Calls {@link #StandardMBean(java.lang.Object, java.lang.Class)

     *       this(this,mbeanInterface)}.

     * This constructor is reserved to subclasses.</p>

     *

     * @param mbeanInterface The Management Interface exported by this

     *        MBean.

     *

     * @exception NotCompliantMBeanException if the <var>mbeanInterface</var>

     *    does not follow JMX design patterns for Management Interfaces, or

     *    if <var>this</var> does not implement the specified interface.

     **/

    protected StandardMBean(Class<?> mbeanInterface)

        throws NotCompliantMBeanException {

        construct(null, mbeanInterface, true, null);

    }

    /**

     * <p>Make a DynamicMBean out of the object

     * <var>implementation</var>, using the specified

     * <var>mbeanInterface</var> class, and choosing whether the

     * resultant MBean is an MXBean.  This constructor can be used

     * to make either Standard MBeans or MXBeans.  Unlike the

     * constructor {@link #StandardMBean(Object, Class)}, it

     * does not throw NotCompliantMBeanException.</p>

     *

     * @param implementation The implementation of this MBean.

     * @param mbeanInterface The Management Interface exported by this

     *        MBean's implementation. If <code>null</code>, then this

     *        object will use standard JMX design pattern to determine

     *        the management interface associated with the given

     *        implementation.

     * @param isMXBean If true, the {@code mbeanInterface} parameter

     * names an MXBean interface and the resultant MBean is an MXBean.

     * @param <T> Allows the compiler to check

     * that {@code implementation} does indeed implement the class

     * described by {@code mbeanInterface}.  The compiler can only

     * check this if {@code mbeanInterface} is a class literal such

     * as {@code MyMBean.class}.

     *

     * @exception IllegalArgumentException if the given

     *    <var>implementation</var> is null, or if the <var>mbeanInterface</var>

     *    does not follow JMX design patterns for Management Interfaces, or

     *    if the given <var>implementation</var> does not implement the

     *    specified interface.

     *

     * @since 1.6

     **/

    public <T> StandardMBean(T implementation, Class<T> mbeanInterface,

                             boolean isMXBean) {

        try {

            MBeanOptions opts = new MBeanOptions();

            if (mbeanInterface == null) {

                mbeanInterface = Util.cast(Introspector.getStandardOrMXBeanInterface(

                        implementation.getClass(), isMXBean));

            }

            if (isMXBean) {

                MXBeanMappingFactory f = MXBeanMappingFactory.forInterface(

                        mbeanInterface);

                opts.setMXBeanMappingFactory(f);

            }

            construct(implementation, mbeanInterface, false, opts);

        } catch (NotCompliantMBeanException e) {

            throw new IllegalArgumentException(e);

        }

    }

    /**

     * <p>Make a DynamicMBean out of <var>this</var>, using the specified

     * <var>mbeanInterface</var> class, and choosing whether the resulting

     * MBean is an MXBean.  This constructor can be used

     * to make either Standard MBeans or MXBeans.  Unlike the

     * constructor {@link #StandardMBean(Object, Class)}, it

     * does not throw NotCompliantMBeanException.</p>

     *

     * <p>Calls {@link #StandardMBean(java.lang.Object, java.lang.Class, boolean)

     *       this(this, mbeanInterface, isMXBean)}.

     * This constructor is reserved to subclasses.</p>

     *

     * @param mbeanInterface The Management Interface exported by this

     *        MBean.

     * @param isMXBean If true, the {@code mbeanInterface} parameter

     * names an MXBean interface and the resultant MBean is an MXBean.

     *

     * @exception IllegalArgumentException if the <var>mbeanInterface</var>

     *    does not follow JMX design patterns for Management Interfaces, or

     *    if <var>this</var> does not implement the specified interface.

     *

     * @since 1.6

     **/

    protected StandardMBean(Class<?> mbeanInterface, boolean isMXBean) {

        try {

            MBeanOptions opts = new MBeanOptions();

            if (mbeanInterface == null) {

                mbeanInterface = Introspector.getStandardOrMXBeanInterface(

                        getClass(), isMXBean);

            }

            if (isMXBean) {

                MXBeanMappingFactory f = MXBeanMappingFactory.forInterface(

                        mbeanInterface);

                opts.setMXBeanMappingFactory(f);

            }

            construct(null, mbeanInterface, true, opts);

        } catch (NotCompliantMBeanException e) {

            throw new IllegalArgumentException(e);

        }

    }

    /**

     * <p>Make a DynamicMBean out of the object

     * <var>implementation</var>, using the specified

     * <var>mbeanInterface</var> class and the specified options.</p>

     *

     * @param implementation The implementation of this MBean.

     * @param mbeanInterface The Management Interface exported by this

     *        MBean's implementation. If <code>null</code>, then this

     *        object will use standard JMX design pattern to determine

     *        the management interface associated with the given

     *        implementation.

     * @param options MBeanOptions that control the operation of the resulting

     *        MBean.

     * @param <T> Allows the compiler to check

     * that {@code implementation} does indeed implement the class

     * described by {@code mbeanInterface}.  The compiler can only

     * check this if {@code mbeanInterface} is a class literal such

     * as {@code MyMBean.class}.

     *

     * @exception IllegalArgumentException if the given

     *    <var>implementation</var> is null, or if the <var>mbeanInterface</var>

     *    does not follow JMX design patterns for Management Interfaces, or

     *    if the given <var>implementation</var> does not implement the

     *    specified interface.

     **/

    public <T> StandardMBean(T implementation,

                             Class<T> mbeanInterface,

                             MBeanOptions options) {

        try {

            construct(implementation, mbeanInterface, false, options);

        } catch (NotCompliantMBeanException e) {

            throw new IllegalArgumentException(e);

        }

    }

    /**

     * <p>Make a DynamicMBean out of <var>this</var>, using the specified

     * <var>mbeanInterface</var> class and the specified options.</p>

     *

     * <p>Calls {@link #StandardMBean(Object, Class, JMX.MBeanOptions)

     *       this(this,mbeanInterface,options)}.

     * This constructor is reserved to subclasses.</p>

     *

     * @param mbeanInterface The Management Interface exported by this

     *        MBean.

     * @param options MBeanOptions that control the operation of the resulting

     *        MBean.

     *

     * @exception IllegalArgumentException if the <var>mbeanInterface</var>

     *    does not follow JMX design patterns for Management Interfaces, or

     *    if <var>this</var> does not implement the specified interface.

     **/

    protected StandardMBean(Class<?> mbeanInterface, MBeanOptions options) {

        try {

            construct(null, mbeanInterface, true, options);

        } catch (NotCompliantMBeanException e) {

            throw new IllegalArgumentException(e);

        }

    }

    /**

     * <p>Replace the implementation object wrapped in this object.</p>

     *

     * @param implementation The new implementation of this Standard MBean

     * (or MXBean). The <code>implementation</code> object must implement

     * the Standard MBean (or MXBean) interface that was supplied when this

     * <code>StandardMBean</code> was constructed.

     *

     * @exception IllegalArgumentException if the given

     * <var>implementation</var> is null.

     *

     * @exception NotCompliantMBeanException if the given

     * <var>implementation</var> does not implement the

     * Standard MBean (or MXBean) interface that was

     * supplied at construction.

     *

     * @see #getImplementation

     **/

    public void setImplementation(Object implementation)

        throws NotCompliantMBeanException {

        if (implementation == null)

            throw new IllegalArgumentException("implementation is null");

        setImplementation2(implementation);

    }

    private <T> void setImplementation2(T implementation)

    throws NotCompliantMBeanException {

        Class<? super T> intf = Util.cast(getMBeanInterface());

        if (this.mbean.isMXBean()) {

            this.mbean = new MXBeanSupport(implementation,

                    intf,

                    options.getMXBeanMappingFactory());

        } else {

            this.mbean = new StandardMBeanSupport(implementation, intf);

        }

    }

    /**

     * Get the implementation of this Standard MBean (or MXBean).

     * @return The implementation of this Standard MBean (or MXBean).

     *