/*

 * Copyright (c) 2002, 2017, Oracle and/or its affiliates. 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package javax.management;

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

import com.sun.jmx.mbeanserver.DescriptorCache;

import com.sun.jmx.mbeanserver.Introspector;

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.lang.System.Logger.Level;

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;

/**

 * <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 DynamicMBean, MBeanRegistration {

    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;

    /**

     * 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>.

     * @exception IllegalArgumentException if the given

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

     **/

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

                               boolean nullImplementationAllowed,

                               boolean isMXBean)

                               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 (isMXBean) {

            if (mbeanInterface == null) {

                mbeanInterface = Util.cast(Introspector.getMXBeanInterface(

                        implementation.getClass()));

            }

            this.mbean = new MXBeanSupport(implementation, mbeanInterface);

        } else {

            if (mbeanInterface == null) {

                mbeanInterface = Util.cast(Introspector.getStandardMBeanInterface(

                        implementation.getClass()));

            }

            this.mbean =

                    new StandardMBeanSupport(implementation, mbeanInterface);

        }

    }

    /**

     * <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, false);

    }

    /**

     * <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, false);

    }

    /**

     * <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 {

            construct(implementation, mbeanInterface, false, isMXBean);

        } 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 {

            construct(null, mbeanInterface, true, isMXBean);

        } 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");

        if (isMXBean()) {

            this.mbean = new MXBeanSupport(implementation,

                    Util.<Class<Object>>cast(getMBeanInterface()));

        } else {

            this.mbean = new StandardMBeanSupport(implementation,

                    Util.<Class<Object>>cast(getMBeanInterface()));

        }

    }

    /**

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

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

     *

     * @see #setImplementation

     **/

    public Object getImplementation() {

        return mbean.getResource();

    }

    /**

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

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

     **/

    public final Class<?> getMBeanInterface() {

        return mbean.getMBeanInterface();

    }

    /**

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

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

     **/

    public Class<?> getImplementationClass() {

        return mbean.getResource().getClass();

    }

    // ------------------------------------------------------------------

    // From the DynamicMBean interface.

    // ------------------------------------------------------------------

    public Object getAttribute(String attribute)

        throws AttributeNotFoundException,

               MBeanException,

               ReflectionException {

        return mbean.getAttribute(attribute);

    }

    // ------------------------------------------------------------------

    // From the DynamicMBean interface.

    // ------------------------------------------------------------------

    public void setAttribute(Attribute attribute)

        throws AttributeNotFoundException,

               InvalidAttributeValueException,

               MBeanException,

               ReflectionException {

        mbean.setAttribute(attribute);

    }

    // ------------------------------------------------------------------

    // From the DynamicMBean interface.

    // ------------------------------------------------------------------

    public AttributeList getAttributes(String[] attributes) {

        return mbean.getAttributes(attributes);

    }

    // ------------------------------------------------------------------

    // From the DynamicMBean interface.

    // ------------------------------------------------------------------

    public AttributeList setAttributes(AttributeList attributes) {

        return mbean.setAttributes(attributes);

    }

    // ------------------------------------------------------------------

    // From the DynamicMBean interface.

    // ------------------------------------------------------------------

    public Object invoke(String actionName, Object params[], String signature[])

            throws MBeanException, ReflectionException {

        return mbean.invoke(actionName, params, signature);

    }

    /**

     * Get the {@link MBeanInfo} for this MBean.

     * <p>

     * This method implements

     * {@link javax.management.DynamicMBean#getMBeanInfo()

     *   DynamicMBean.getMBeanInfo()}.

     * <p>

     * This method first calls {@link #getCachedMBeanInfo()} in order to

     * retrieve the cached MBeanInfo for this MBean, if any. If the

     * MBeanInfo returned by {@link #getCachedMBeanInfo()} is not null,

     * then it is returned.<br>

     * Otherwise, this method builds a default MBeanInfo for this MBean,

     * using the Management Interface specified for this MBean.

     * <p>

     * While building the MBeanInfo, this method calls the customization

     * hooks that make it possible for subclasses to supply their custom

     * descriptions, parameter names, etc...<br>

     * Finally, it calls {@link #cacheMBeanInfo(javax.management.MBeanInfo)

     * cacheMBeanInfo()} in order to cache the new MBeanInfo.

     * @return The cached MBeanInfo for that MBean, if not null, or a

     *         newly built MBeanInfo if none was cached.

     **/

    public MBeanInfo getMBeanInfo() {

        try {

            final MBeanInfo cached = getCachedMBeanInfo();

            if (cached != null) return cached;

        } catch (RuntimeException x) {

            if (MISC_LOGGER.isLoggable(Level.DEBUG)) {

                MISC_LOGGER.log(Level.DEBUG,

                        "Failed to get cached MBeanInfo", x);

            }

        }

        if (MISC_LOGGER.isLoggable(Level.TRACE)) {

            MISC_LOGGER.log(Level.TRACE,

                    "Building MBeanInfo for " +

                    getImplementationClass().getName());

        }

        MBeanSupport<?> msupport = mbean;

        final MBeanInfo bi = msupport.getMBeanInfo();

        final Object impl = msupport.getResource();

        final boolean immutableInfo = immutableInfo(this.getClass());

        final String                  cname = getClassName(bi);

        final String                  text  = getDescription(bi);

        final MBeanConstructorInfo[]  ctors = getConstructors(bi,impl);

        final MBeanAttributeInfo[]    attrs = getAttributes(bi);

        final MBeanOperationInfo[]    ops   = getOperations(bi);

        final MBeanNotificationInfo[] ntfs  = getNotifications(bi);

        final Descriptor              desc  = getDescriptor(bi, immutableInfo);

        final MBeanInfo nmbi = new MBeanInfo(

                cname, text, attrs, ctors, ops, ntfs, desc);

        try {

            cacheMBeanInfo(nmbi);

        } catch (RuntimeException x) {

            if (MISC_LOGGER.isLoggable(Level.DEBUG)) {

                MISC_LOGGER.log(Level.DEBUG,

                        "Failed to cache MBeanInfo", x);

            }

        }

        return nmbi;

    }

    /**

     * Customization hook:

     * Get the className that will be used in the MBeanInfo returned by

     * this MBean.

     * <br>

     * Subclasses may redefine this method in order to supply their

     * custom class name.  The default implementation returns

     * {@link MBeanInfo#getClassName() info.getClassName()}.

     * @param info The default MBeanInfo derived by reflection.

     * @return the class name for the new MBeanInfo.

     **/

    protected String getClassName(MBeanInfo info) {

        if (info == null) return getImplementationClass().getName();

        return info.getClassName();

    }

    /**

     * Customization hook:

     * Get the description that will be used in the MBeanInfo returned by

     * this MBean.

     * <br>

     * Subclasses may redefine this method in order to supply their

     * custom MBean description.  The default implementation returns

     * {@link MBeanInfo#getDescription() info.getDescription()}.

     * @param info The default MBeanInfo derived by reflection.

     * @return the description for the new MBeanInfo.

     **/

    protected String getDescription(MBeanInfo info) {

        if (info == null) return null;

        return info.getDescription();

    }

    /**

     * <p>Customization hook:

     * Get the description that will be used in the MBeanFeatureInfo

     * returned by this MBean.</p>

     *

     * <p>Subclasses may redefine this method in order to supply

     * their custom description.  The default implementation returns

     * {@link MBeanFeatureInfo#getDescription()

     * info.getDescription()}.</p>

     *

     * <p>This method is called by

     *      {@link #getDescription(MBeanAttributeInfo)},

     *      {@link #getDescription(MBeanOperationInfo)},

     *      {@link #getDescription(MBeanConstructorInfo)}.</p>

     *