/*

 * Copyright (c) 2005, 2008, 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 com.sun.jmx.mbeanserver;

import static com.sun.jmx.mbeanserver.Util.*;

import java.util.Map;

import java.lang.ref.WeakReference;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Proxy;

import java.security.AccessController;

import javax.management.InstanceAlreadyExistsException;

import javax.management.JMX;

import javax.management.MBeanServerConnection;

import javax.management.MBeanServerInvocationHandler;

import javax.management.ObjectName;

import javax.management.openmbean.OpenDataException;

/**

 * @since 1.6

 */

/*

 * This class handles the mapping between MXBean references and

 * ObjectNames.  Consider an MXBean interface like this:

 *

 * public interface ModuleMXBean {

 *     ProductMXBean getProduct();

 *     void setProduct(ProductMXBean product);

 * }

 *

 * This defines an attribute called "Product" whose originalType will

 * be ProductMXBean and whose openType will be ObjectName.  The

 * mapping happens as follows.

 *

 * When the MXBean's getProduct method is called, it is supposed to

 * return a reference to another MXBean, or a proxy for another

 * MXBean.  The MXBean layer has to convert this into an ObjectName.

 * If it's a reference to another MXBean, it needs to be able to look

 * up the name under which that MXBean has been registered in this

 * MBeanServer; this is the purpose of the mxbeanToObjectName map.  If

 * it's a proxy, it can check that the MBeanServer matches and if so

 * extract the ObjectName from the proxy.

 *

 * When the setProduct method is called on a proxy for this MXBean,

 * the argument can be either an MXBean reference (only really logical

 * if the proxy has a local MBeanServer) or another proxy.  So the

 * mapping logic is the same as for getProduct on the MXBean.

 *

 * When the MXBean's setProduct method is called, it needs to convert

 * the ObjectName into an object implementing the ProductMXBean

 * interface.  We could have a lookup table that reverses

 * mxbeanToObjectName, but this could violate the general JMX property

 * that you cannot obtain a reference to an MBean object.  So we

 * always use a proxy for this.  However we do have an

 * objectNameToProxy map that allows us to reuse proxy instances.

 *

 * When the getProduct method is called on a proxy for this MXBean, it

 * must convert the returned ObjectName into an instance of

 * ProductMXBean.  Again it can do this by making a proxy.

 *

 * From the above, it is clear that the logic for getX on an MXBean is

 * the same as for setX on a proxy, and vice versa.

 */

public class MXBeanLookup {

    private MXBeanLookup(MBeanServerConnection mbsc) {

        this.mbsc = mbsc;

    }

    static MXBeanLookup lookupFor(MBeanServerConnection mbsc) {

        synchronized (mbscToLookup) {

            WeakReference<MXBeanLookup> weakLookup = mbscToLookup.get(mbsc);

            MXBeanLookup lookup = (weakLookup == null) ? null : weakLookup.get();

            if (lookup == null) {

                lookup = new MXBeanLookup(mbsc);

                mbscToLookup.put(mbsc, new WeakReference<MXBeanLookup>(lookup));

            }

            return lookup;

        }

    }

    synchronized <T> T objectNameToMXBean(ObjectName name, Class<T> type) {

        WeakReference<Object> wr = objectNameToProxy.get(name);

        if (wr != null) {

            Object proxy = wr.get();

            if (type.isInstance(proxy))

                return type.cast(proxy);

        }

        T proxy = JMX.newMXBeanProxy(mbsc, name, type);

        objectNameToProxy.put(name, new WeakReference<Object>(proxy));

        return proxy;

    }

    synchronized ObjectName mxbeanToObjectName(Object mxbean)

    throws OpenDataException {

        String wrong;

        if (mxbean instanceof Proxy) {

            InvocationHandler ih = Proxy.getInvocationHandler(mxbean);

            if (ih instanceof MBeanServerInvocationHandler) {

                MBeanServerInvocationHandler mbsih =

                        (MBeanServerInvocationHandler) ih;

                if (mbsih.getMBeanServerConnection().equals(mbsc))

                    return mbsih.getObjectName();

                else

                    wrong = "proxy for a different MBeanServer";

            } else

                wrong = "not a JMX proxy";

        } else {

            ObjectName name = mxbeanToObjectName.get(mxbean);

            if (name != null)

                return name;

            wrong = "not an MXBean registered in this MBeanServer";

        }

        String s = (mxbean == null) ?

            "null" : "object of type " + mxbean.getClass().getName();

        throw new OpenDataException(

                "Could not convert " + s + " to an ObjectName: " + wrong);

        // Message will be strange if mxbean is null but it is not

        // supposed to be.

    }

    synchronized void addReference(ObjectName name, Object mxbean)

    throws InstanceAlreadyExistsException {

        ObjectName existing = mxbeanToObjectName.get(mxbean);

        if (existing != null) {

            String multiname = AccessController.doPrivileged(

                    new GetPropertyAction("jmx.mxbean.multiname"));

            if (!"true".equalsIgnoreCase(multiname)) {

                throw new InstanceAlreadyExistsException(

                        "MXBean already registered with name " + existing);

            }

        }

        mxbeanToObjectName.put(mxbean, name);

    }

    synchronized boolean removeReference(ObjectName name, Object mxbean) {

        if (name.equals(mxbeanToObjectName.get(mxbean))) {

            mxbeanToObjectName.remove(mxbean);

            return true;

        } else

            return false;

        /* removeReference can be called when the above condition fails,

         * notably if you try to register the same MXBean twice.

         */

    }

    static MXBeanLookup getLookup() {

        return currentLookup.get();

    }

    static void setLookup(MXBeanLookup lookup) {

        currentLookup.set(lookup);

    }

    private static final ThreadLocal<MXBeanLookup> currentLookup =

            new ThreadLocal<MXBeanLookup>();

    private final MBeanServerConnection mbsc;

    private final WeakIdentityHashMap<Object, ObjectName>

        mxbeanToObjectName = WeakIdentityHashMap.make();

    private final Map<ObjectName, WeakReference<Object>>

        objectNameToProxy = newMap();

    private static final WeakIdentityHashMap<MBeanServerConnection,

                                             WeakReference<MXBeanLookup>>

        mbscToLookup = WeakIdentityHashMap.make();

}