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