--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/management/MBeanServer/OldMBeanServerTest.java Thu Jul 31 15:31:13 2008 +0200
@@ -0,0 +1,1410 @@
+/*
+ * Copyright 2007 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.
+ *
+ * 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.
+ */
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.management.ManagementFactory;
+import java.lang.ref.WeakReference;
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import javax.management.Attribute;
+import javax.management.AttributeList;
+import javax.management.AttributeNotFoundException;
+import javax.management.DynamicMBean;
+import javax.management.InstanceAlreadyExistsException;
+import javax.management.InstanceNotFoundException;
+import javax.management.IntrospectionException;
+import javax.management.InvalidAttributeValueException;
+import javax.management.ListenerNotFoundException;
+import javax.management.MBeanAttributeInfo;
+import javax.management.MBeanConstructorInfo;
+import javax.management.MBeanException;
+import javax.management.MBeanInfo;
+import javax.management.MBeanNotificationInfo;
+import javax.management.MBeanOperationInfo;
+import javax.management.MBeanRegistration;
+import javax.management.MBeanRegistrationException;
+import javax.management.MBeanServer;
+import javax.management.MBeanServerBuilder;
+import javax.management.MBeanServerConnection;
+import javax.management.MBeanServerDelegate;
+import javax.management.MBeanServerFactory;
+import javax.management.MBeanServerNotification;
+import javax.management.MalformedObjectNameException;
+import javax.management.NotCompliantMBeanException;
+import javax.management.Notification;
+import javax.management.NotificationBroadcaster;
+import javax.management.NotificationBroadcasterSupport;
+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.QueryEval;
+import javax.management.QueryExp;
+import javax.management.ReflectionException;
+import javax.management.RuntimeErrorException;
+import javax.management.RuntimeMBeanException;
+import javax.management.StandardMBean;
+import javax.management.loading.ClassLoaderRepository;
+import javax.management.remote.JMXConnector;
+import javax.management.remote.JMXConnectorFactory;
+import javax.management.remote.JMXConnectorServer;
+import javax.management.remote.JMXConnectorServerFactory;
+import javax.management.remote.JMXServiceURL;
+
+/*
+ * @test OldMBeanServerTest.java
+ * @bug 5072268
+ * @summary Test that nothing assumes a post-1.2 MBeanServer
+ * @author Eamonn McManus
+ * @run main/othervm -ea OldMBeanServerTest
+ */
+
+/*
+ * We defined the MBeanServerBuilder class and the associated system
+ * property javax.management.builder.initial in version 1.2 of the JMX
+ * spec. That amounts to a guarantee that someone can set the property
+ * to an MBeanServer that only knows about JMX 1.2 semantics, and if they
+ * only do JMX 1.2 operations, everything should work. This test is a
+ * sanity check that ensures we don't inadvertently make any API changes
+ * that stop that from being true. It includes a complete (if slow)
+ * MBeanServer implementation. That implementation doesn't replicate the
+ * mandated exception behaviour everywhere, though, since there's lots of
+ * arbitrary cruft in that. Also, the behaviour of concurrent unregisterMBean
+ * calls is incorrect in detail.
+ */
+
+public class OldMBeanServerTest {
+ private static MBeanServerConnection mbsc;
+ private static String failure;
+
+ public static void main(String[] args) throws Exception {
+ if (!OldMBeanServerTest.class.desiredAssertionStatus())
+ throw new Exception("Test must be run with -ea");
+
+ System.setProperty("javax.management.builder.initial",
+ OldMBeanServerBuilder.class.getName());
+ assert MBeanServerFactory.newMBeanServer() instanceof OldMBeanServer;
+
+ System.out.println("=== RUNNING TESTS WITH LOCAL MBEANSERVER ===");
+ runTests(new Callable<MBeanServerConnection>() {
+ public MBeanServerConnection call() {
+ return MBeanServerFactory.newMBeanServer();
+ }
+ }, null);
+
+ System.out.println("=== RUNNING TESTS THROUGH CONNECTOR ===");
+ ConnectionBuilder builder = new ConnectionBuilder();
+ runTests(builder, builder);
+
+ if (failure == null)
+ System.out.println("TEST PASSED");
+ else
+ throw new Exception("TEST FAILED: " + failure);
+ }
+
+ private static class ConnectionBuilder
+ implements Callable<MBeanServerConnection>, Runnable {
+ private JMXConnector connector;
+ public MBeanServerConnection call() {
+ MBeanServer mbs = MBeanServerFactory.newMBeanServer();
+ try {
+ JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");
+ JMXConnectorServer cs =
+ JMXConnectorServerFactory.newJMXConnectorServer(
+ url, null, mbs);
+ cs.start();
+ JMXServiceURL addr = cs.getAddress();
+ connector = JMXConnectorFactory.connect(addr);
+ return connector.getMBeanServerConnection();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ public void run() {
+ if (connector != null) {
+ try {
+ connector.close();
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+ }
+
+ private static void runTests(
+ Callable<MBeanServerConnection> maker, Runnable breaker)
+ throws Exception {
+ for (Method m : OldMBeanServerTest.class.getDeclaredMethods()) {
+ if (Modifier.isStatic(m.getModifiers()) &&
+ m.getName().startsWith("test") &&
+ m.getParameterTypes().length == 0) {
+ ExpectException expexc = m.getAnnotation(ExpectException.class);
+ mbsc = maker.call();
+ try {
+ m.invoke(null);
+ if (expexc != null) {
+ failure =
+ m.getName() + " did not got expected exception " +
+ expexc.value().getName();
+ System.out.println(failure);
+ } else
+ System.out.println(m.getName() + " OK");
+ } catch (InvocationTargetException ite) {
+ Throwable t = ite.getCause();
+ String prob = null;
+ if (expexc != null) {
+ if (expexc.value().isInstance(t)) {
+ System.out.println(m.getName() + " OK (got expected " +
+ expexc.value().getName() + ")");
+ } else
+ prob = "got wrong exception";
+ } else
+ prob = "got exception";
+ if (prob != null) {
+ failure = m.getName() + ": " + prob + " " +
+ t.getClass().getName();
+ System.out.println(failure);
+ t.printStackTrace(System.out);
+ }
+ } finally {
+ if (breaker != null)
+ breaker.run();
+ }
+ }
+ }
+ }
+
+ @Retention(RetentionPolicy.RUNTIME)
+ private static @interface ExpectException {
+ Class<? extends Exception> value();
+ }
+
+ public static interface BoringMBean {
+ public String getName();
+ public int add(int x, int y);
+ }
+
+ // This class is Serializable so we can createMBean a StandardMBean
+ // that contains it. Not recommended practice in general --
+ // should we have a StandardMBean constructor that takes a class
+ // name and constructor parameters?
+ public static class Boring implements BoringMBean, Serializable {
+ public String getName() {
+ return "Jessica";
+ }
+
+ public int add(int x, int y) {
+ return x + y;
+ }
+ }
+
+ public static interface BoringNotifierMBean extends BoringMBean {
+ public void send();
+ }
+
+ public static class BoringNotifier
+ extends Boring implements BoringNotifierMBean, NotificationBroadcaster {
+ private final NotificationBroadcasterSupport nbs =
+ new NotificationBroadcasterSupport();
+
+ public void addNotificationListener(
+ NotificationListener listener, NotificationFilter filter, Object handback)
+ throws IllegalArgumentException {
+ nbs.addNotificationListener(listener, filter, handback);
+ }
+
+ public void removeNotificationListener(NotificationListener listener)
+ throws ListenerNotFoundException {
+ nbs.removeNotificationListener(listener);
+ }
+
+ public MBeanNotificationInfo[] getNotificationInfo() {
+ return null;
+ }
+
+ public void send() {
+ Notification n = new Notification("type.type", this, 0L);
+ nbs.sendNotification(n);
+ }
+ }
+
+ private static class CountListener implements NotificationListener {
+ volatile int count;
+ public void handleNotification(Notification n, Object h) {
+ if (h == null)
+ h = 1;
+ count += (Integer) h;
+ }
+ void waitForCount(int expect) throws InterruptedException {
+ long deadline = System.currentTimeMillis() + 2000L;
+ while (count < expect && System.currentTimeMillis() < deadline)
+ Thread.sleep(1);
+ assert count == expect;
+ }
+ }
+
+ private static void testBasic() throws Exception {
+ CountListener countListener = new CountListener();
+ mbsc.addNotificationListener(
+ MBeanServerDelegate.DELEGATE_NAME, countListener, null, null);
+ assert countListener.count == 0;
+ ObjectName name = new ObjectName("a:b=c");
+ if (mbsc instanceof MBeanServer)
+ ((MBeanServer) mbsc).registerMBean(new Boring(), name);
+ else
+ mbsc.createMBean(Boring.class.getName(), name);
+ countListener.waitForCount(1);
+ assert mbsc.isRegistered(name);
+ assert mbsc.queryNames(null, null).contains(name);
+ assert mbsc.getAttribute(name, "Name").equals("Jessica");
+ assert mbsc.invoke(
+ name, "add", new Object[] {2, 3}, new String[] {"int", "int"})
+ .equals(5);
+ mbsc.unregisterMBean(name);
+ countListener.waitForCount(2);
+ assert !mbsc.isRegistered(name);
+ assert !mbsc.queryNames(null, null).contains(name);
+
+ mbsc.createMBean(BoringNotifier.class.getName(), name);
+ countListener.waitForCount(3);
+ CountListener boringListener = new CountListener();
+ class AlwaysNotificationFilter implements NotificationFilter {
+ public boolean isNotificationEnabled(Notification notification) {
+ return true;
+ }
+ }
+ mbsc.addNotificationListener(
+ name, boringListener, new AlwaysNotificationFilter(), 5);
+ mbsc.invoke(name, "send", null, null);
+ boringListener.waitForCount(5);
+ }
+
+ private static void testPrintAttrs() throws Exception {
+ printAttrs(mbsc, null);
+ }
+
+ private static void testPlatformMBeanServer() throws Exception {
+ MBeanServer pmbs = ManagementFactory.getPlatformMBeanServer();
+ assert pmbs instanceof OldMBeanServer;
+ // Preceding assertion could be violated if at some stage we wrap
+ // the Platform MBeanServer. In that case we can still check that
+ // it is ultimately an OldMBeanServer for example by adding a
+ // counter to getAttribute and checking that it is incremented
+ // when we call pmbs.getAttribute.
+
+ printAttrs(pmbs, UnsupportedOperationException.class);
+ ObjectName memoryMXBeanName =
+ new ObjectName(ManagementFactory.MEMORY_MXBEAN_NAME);
+ pmbs.invoke(memoryMXBeanName, "gc", null, null);
+ }
+
+ private static void printAttrs(
+ MBeanServerConnection mbsc1, Class<? extends Exception> expectX)
+ throws Exception {
+ Set<ObjectName> names = mbsc1.queryNames(null, null);
+ for (ObjectName name : names) {
+ System.out.println(name + ":");
+ MBeanInfo mbi = mbsc1.getMBeanInfo(name);
+ MBeanAttributeInfo[] mbais = mbi.getAttributes();
+ for (MBeanAttributeInfo mbai : mbais) {
+ String attr = mbai.getName();
+ Object value;
+ try {
+ value = mbsc1.getAttribute(name, attr);
+ } catch (Exception e) {
+ if (expectX != null && expectX.isInstance(e))
+ value = "<" + e + ">";
+ else
+ throw e;
+ }
+ String s = " " + attr + " = " + value;
+ if (s.length() > 80)
+ s = s.substring(0, 77) + "...";
+ System.out.println(s);
+ }
+ }
+ }
+
+ private static void testJavaxManagementStandardMBean() throws Exception {
+ ObjectName name = new ObjectName("a:b=c");
+ Object mbean = new StandardMBean(new Boring(), BoringMBean.class);
+ mbsc.createMBean(
+ StandardMBean.class.getName(), name,
+ new Object[] {new Boring(), BoringMBean.class},
+ new String[] {Object.class.getName(), Class.class.getName()});
+ assert mbsc.getAttribute(name, "Name").equals("Jessica");
+ assert mbsc.invoke(
+ name, "add", new Object[] {2, 3}, new String[] {"int", "int"})
+ .equals(5);
+ mbsc.unregisterMBean(name);
+ }
+
+ private static void testConnector() throws Exception {
+ }
+
+ public static class OldMBeanServerBuilder extends MBeanServerBuilder {
+ public MBeanServer newMBeanServer(
+ String defaultDomain, MBeanServer outer, MBeanServerDelegate delegate) {
+ return new OldMBeanServer(defaultDomain, delegate);
+ }
+ }
+
+ public static class OldMBeanServer implements MBeanServer {
+ // We pretend there's a ClassLoader MBean representing the Class Loader
+ // Repository and intercept references to it where necessary to keep up
+ // the pretence. This allows us to fake the right behaviour for
+ // the omitted-ClassLoader versions of createMBean and instantiate
+ // (which are not the same as passing a null for the ClassLoader parameter
+ // of the versions that have one).
+ private static final ObjectName clrName;
+ static {
+ try {
+ clrName =
+ new ObjectName("JMImplementation:type=ClassLoaderRepository");
+ } catch (MalformedObjectNameException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ private final ConcurrentMap<ObjectName, DynamicMBean> mbeans =
+ new ConcurrentHashMap<ObjectName, DynamicMBean>();
+ private final ConcurrentMap<ObjectName, ListenerTable> listenerMap =
+ new ConcurrentHashMap<ObjectName, ListenerTable>();
+ private final String defaultDomain;
+ private final MBeanServerDelegate delegate;
+ private final ClassLoaderRepositoryImpl clr =
+ new ClassLoaderRepositoryImpl();
+
+ OldMBeanServer(String defaultDomain, MBeanServerDelegate delegate) {
+ this.defaultDomain = defaultDomain;
+ this.delegate = delegate;
+ try {
+ registerMBean(delegate, MBeanServerDelegate.DELEGATE_NAME);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ public ObjectInstance createMBean(String className, ObjectName name)
+ throws ReflectionException, InstanceAlreadyExistsException,
+ MBeanRegistrationException, MBeanException,
+ NotCompliantMBeanException {
+ return createMBean(className, name, null, null);
+ }
+
+ public ObjectInstance createMBean(
+ String className, ObjectName name, ObjectName loaderName)
+ throws ReflectionException, InstanceAlreadyExistsException,
+ MBeanRegistrationException, MBeanException,
+ NotCompliantMBeanException, InstanceNotFoundException {
+ return createMBean(className, name, loaderName, null, null);
+ }
+
+ public ObjectInstance createMBean(
+ String className, ObjectName name, Object[] params, String[] signature)
+ throws ReflectionException, InstanceAlreadyExistsException,
+ MBeanRegistrationException, MBeanException,
+ NotCompliantMBeanException {
+ try {
+ return createMBean(className, name, clrName, params, signature);
+ } catch (InstanceNotFoundException ex) {
+ throw new RuntimeException(ex); // can't happen
+ }
+ }
+
+ public ObjectInstance createMBean(
+ String className, ObjectName name, ObjectName loaderName,
+ Object[] params, String[] signature)
+ throws ReflectionException, InstanceAlreadyExistsException,
+ MBeanRegistrationException, MBeanException,
+ NotCompliantMBeanException, InstanceNotFoundException {
+ Object mbean = instantiate(className, loaderName, params, signature);
+ return registerMBean(mbean, name);
+ }
+
+ private void forbidJMImpl(ObjectName name) {
+ if (name.getDomain().equals("JMImplementation") &&
+ mbeans.containsKey(MBeanServerDelegate.DELEGATE_NAME))
+ throw new IllegalArgumentException("JMImplementation reserved");
+ }
+
+ public ObjectInstance registerMBean(Object object, ObjectName name)
+ throws InstanceAlreadyExistsException, MBeanRegistrationException,
+ NotCompliantMBeanException {
+ forbidJMImpl(name);
+ if (name.isPattern())
+ throw new IllegalArgumentException(name.toString());
+ // This is the only place we check for wildcards. Since you
+ // can't register a wildcard name, other operations that supply
+ // one will get InstanceNotFoundException when they look it up.
+
+ DynamicMBean mbean;
+ if (object instanceof DynamicMBean)
+ mbean = (DynamicMBean) object;
+ else
+ mbean = standardToDynamic(object);
+ MBeanRegistration reg = mbeanRegistration(object);
+ try {
+ name = reg.preRegister(this, name);
+ } catch (Exception e) {
+ throw new MBeanRegistrationException(e);
+ }
+ DynamicMBean put = mbeans.putIfAbsent(name, mbean);
+ if (put != null) {
+ reg.postRegister(false);
+ throw new InstanceAlreadyExistsException(name.toString());
+ }
+ reg.postRegister(true);
+
+ if (object instanceof ClassLoader)
+ clr.addLoader((ClassLoader) object);
+
+ Notification n = new MBeanServerNotification(
+ MBeanServerNotification.REGISTRATION_NOTIFICATION,
+ MBeanServerDelegate.DELEGATE_NAME,
+ 0,
+ name);
+ delegate.sendNotification(n);
+
+ String className = mbean.getMBeanInfo().getClassName();
+ return new ObjectInstance(name, className);
+ }
+
+ public void unregisterMBean(ObjectName name)
+ throws InstanceNotFoundException, MBeanRegistrationException {
+
+ forbidJMImpl(name);
+
+ DynamicMBean mbean = getMBean(name);
+ if (mbean == null)
+ throw new InstanceNotFoundException(name.toString());
+
+ MBeanRegistration reg = mbeanRegistration(mbean);
+ try {
+ reg.preDeregister();
+ } catch (Exception e) {
+ throw new MBeanRegistrationException(e);
+ }
+ if (!mbeans.remove(name, mbean))
+ throw new InstanceNotFoundException(name.toString());
+ // This is incorrect because we've invoked preDeregister
+
+ Object userMBean = getUserMBean(mbean);
+ if (userMBean instanceof ClassLoader)
+ clr.removeLoader((ClassLoader) userMBean);
+
+ Notification n = new MBeanServerNotification(
+ MBeanServerNotification.REGISTRATION_NOTIFICATION,
+ MBeanServerDelegate.DELEGATE_NAME,
+ 0,
+ name);
+ delegate.sendNotification(n);
+
+ reg.postDeregister();
+ }
+
+ public ObjectInstance getObjectInstance(ObjectName name)
+ throws InstanceNotFoundException {
+ DynamicMBean mbean = getMBean(name);
+ return new ObjectInstance(name, mbean.getMBeanInfo().getClassName());
+ }
+
+ private static class TrueQueryExp implements QueryExp {
+ public boolean apply(ObjectName name) {
+ return true;
+ }
+
+ public void setMBeanServer(MBeanServer s) {}
+ }
+ private static final QueryExp trueQuery = new TrueQueryExp();
+
+ public Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query) {
+ Set<ObjectInstance> instances = newSet();
+ if (name == null)
+ name = ObjectName.WILDCARD;
+ if (query == null)
+ query = trueQuery;
+ MBeanServer oldMBS = QueryEval.getMBeanServer();
+ try {
+ query.setMBeanServer(this);
+ for (ObjectName n : mbeans.keySet()) {
+ if (name.apply(n)) {
+ try {
+ if (query.apply(n))
+ instances.add(getObjectInstance(n));
+ } catch (Exception e) {
+ // OK: Ignore this MBean in the result
+ }
+ }
+ }
+ } finally {
+ query.setMBeanServer(oldMBS);
+ }
+ return instances;
+ }
+
+ public Set<ObjectName> queryNames(ObjectName name, QueryExp query) {
+ Set<ObjectInstance> instances = queryMBeans(name, query);
+ Set<ObjectName> names = newSet();
+ for (ObjectInstance instance : instances)
+ names.add(instance.getObjectName());
+ return names;
+ }
+
+ public boolean isRegistered(ObjectName name) {
+ return mbeans.containsKey(name);
+ }
+
+ public Integer getMBeanCount() {
+ return mbeans.size();
+ }
+
+ public Object getAttribute(ObjectName name, String attribute)
+ throws MBeanException, AttributeNotFoundException,
+ InstanceNotFoundException, ReflectionException {
+ return getMBean(name).getAttribute(attribute);
+ }
+
+ public AttributeList getAttributes(ObjectName name, String[] attributes)
+ throws InstanceNotFoundException, ReflectionException {
+ return getMBean(name).getAttributes(attributes);
+ }
+
+ public void setAttribute(ObjectName name, Attribute attribute)
+ throws InstanceNotFoundException, AttributeNotFoundException,
+ InvalidAttributeValueException, MBeanException,
+ ReflectionException {
+ getMBean(name).setAttribute(attribute);
+ }
+
+ public AttributeList setAttributes(
+ ObjectName name, AttributeList attributes)
+ throws InstanceNotFoundException, ReflectionException {
+ return getMBean(name).setAttributes(attributes);
+ }
+
+ public Object invoke(
+ ObjectName name, String operationName, Object[] params,
+ String[] signature)
+ throws InstanceNotFoundException, MBeanException, ReflectionException {
+ return getMBean(name).invoke(operationName, params, signature);
+ }
+
+ public String getDefaultDomain() {
+ return defaultDomain;
+ }
+
+ public String[] getDomains() {
+ Set<String> domains = newSet();
+ for (ObjectName name : mbeans.keySet())
+ domains.add(name.getDomain());
+ return domains.toArray(new String[0]);
+ }
+
+ // ClassCastException if MBean is not a NotificationBroadcaster
+ public void addNotificationListener(
+ ObjectName name, NotificationListener listener,
+ NotificationFilter filter, Object handback)
+ throws InstanceNotFoundException {
+ NotificationBroadcaster userMBean =
+ (NotificationBroadcaster) getUserMBean(name);
+ NotificationListener wrappedListener =
+ wrappedListener(name, userMBean, listener);
+ userMBean.addNotificationListener(wrappedListener, filter, handback);
+ }
+
+ public void addNotificationListener(
+ ObjectName name, ObjectName listener,
+ NotificationFilter filter, Object handback)
+ throws InstanceNotFoundException {
+ NotificationListener nl =
+ (NotificationListener) getUserMBean(listener);
+ addNotificationListener(name, nl, filter, handback);
+ }
+
+ public void removeNotificationListener(
+ ObjectName name, ObjectName listener)
+ throws InstanceNotFoundException, ListenerNotFoundException {
+ NotificationListener nl =
+ (NotificationListener) getUserMBean(listener);
+ removeNotificationListener(name, nl);
+ }
+
+ public void removeNotificationListener(
+ ObjectName name, ObjectName listener,
+ NotificationFilter filter, Object handback)
+ throws InstanceNotFoundException, ListenerNotFoundException {
+ NotificationListener nl =
+ (NotificationListener) getUserMBean(listener);
+ removeNotificationListener(name, nl, filter, handback);
+ }
+
+ public void removeNotificationListener(
+ ObjectName name, NotificationListener listener)
+ throws InstanceNotFoundException, ListenerNotFoundException {
+ NotificationBroadcaster userMBean =
+ (NotificationBroadcaster) getUserMBean(name);
+ NotificationListener wrappedListener =
+ wrappedListener(name, userMBean, listener);
+ userMBean.removeNotificationListener(wrappedListener);
+ }
+
+ public void removeNotificationListener(
+ ObjectName name, NotificationListener listener,
+ NotificationFilter filter, Object handback)
+ throws InstanceNotFoundException, ListenerNotFoundException {
+ NotificationEmitter userMBean =
+ (NotificationEmitter) getMBean(name);
+ NotificationListener wrappedListener =
+ wrappedListener(name, userMBean, listener);
+ userMBean.removeNotificationListener(wrappedListener, filter, handback);
+ }
+
+ public MBeanInfo getMBeanInfo(ObjectName name)
+ throws InstanceNotFoundException, IntrospectionException,
+ ReflectionException {
+ return getMBean(name).getMBeanInfo();
+ }
+
+ public boolean isInstanceOf(ObjectName name, String className)
+ throws InstanceNotFoundException {
+ DynamicMBean mbean = getMBean(name);
+ String mbeanClassName = mbean.getMBeanInfo().getClassName();
+ if (className.equals(mbeanClassName))
+ return true;
+ ClassLoader loader = getUserMBean(mbean).getClass().getClassLoader();
+ try {
+ Class<?> mbeanClass = Class.forName(mbeanClassName, false, loader);
+ Class<?> isInstClass = Class.forName(className, false, loader);
+ return isInstClass.isAssignableFrom(mbeanClass);
+ } catch (ClassNotFoundException e) {
+ return false;
+ }
+ }
+
+ public Object instantiate(String className)
+ throws ReflectionException, MBeanException {
+ return instantiate(className, null, null);
+ }
+
+ public Object instantiate(String className, ObjectName loaderName)
+ throws ReflectionException, MBeanException, InstanceNotFoundException {
+ return instantiate(className, loaderName, null, null);
+ }
+
+ public Object instantiate(
+ String className, Object[] params, String[] signature)
+ throws ReflectionException, MBeanException {
+ try {
+ return instantiate(className, clrName, params, signature);
+ } catch (InstanceNotFoundException e) {
+ throw new RuntimeException(e); // can't happen
+ }
+ }
+
+ public Object instantiate(
+ String className, ObjectName loaderName,
+ Object[] params, String[] signature)
+ throws ReflectionException, MBeanException, InstanceNotFoundException {
+
+ if (params == null)
+ params = new Object[0];
+ if (signature == null)
+ signature = new String[0];
+
+ ClassLoader loader;
+ if (loaderName == null)
+ loader = this.getClass().getClassLoader();
+ else if (loaderName.equals(clrName))
+ loader = clr;
+ else
+ loader = (ClassLoader) getMBean(loaderName);
+
+ Class<?> c;
+ try {
+ c = Class.forName(className, false, loader);
+ } catch (ClassNotFoundException e) {
+ throw new ReflectionException(e);
+ }
+
+ Constructor[] constrs = c.getConstructors();
+ Constructor found = null;
+ findconstr:
+ for (Constructor constr : constrs) {
+ Class<?>[] cTypes = constr.getParameterTypes();
+ if (cTypes.length == signature.length) {
+ for (int i = 0; i < cTypes.length; i++) {
+ if (!cTypes[i].getName().equals(signature[i]))
+ continue findconstr;
+ }
+ found = constr;
+ break findconstr;
+ }
+ }
+ if (found == null) {
+ Exception x = new NoSuchMethodException(
+ className + Arrays.toString(signature));
+ throw new ReflectionException(x);
+ }
+ return invokeSomething(found, null, params);
+ }
+
+ @Deprecated
+ public ObjectInputStream deserialize(ObjectName name, byte[] data)
+ throws InstanceNotFoundException, OperationsException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Deprecated
+ public ObjectInputStream deserialize(String className, byte[] data)
+ throws OperationsException, ReflectionException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Deprecated
+ public ObjectInputStream deserialize(
+ String className, ObjectName loaderName, byte[] data)
+ throws InstanceNotFoundException, OperationsException, ReflectionException {
+ throw new UnsupportedOperationException();
+ }
+
+ public ClassLoader getClassLoaderFor(ObjectName mbeanName)
+ throws InstanceNotFoundException {
+ DynamicMBean mbean = getMBean(mbeanName);
+ Object userMBean = getUserMBean(mbean);
+ return userMBean.getClass().getClassLoader();
+ }
+
+ public ClassLoader getClassLoader(ObjectName loaderName)
+ throws InstanceNotFoundException {
+ return (ClassLoader) getMBean(loaderName);
+ }
+
+ public ClassLoaderRepository getClassLoaderRepository() {
+ return new ClassLoaderRepository() {
+ public Class<?> loadClass(String className)
+ throws ClassNotFoundException {
+ return clr.loadClass(className);
+ }
+
+ public Class<?> loadClassWithout(
+ ClassLoader exclude, String className)
+ throws ClassNotFoundException {
+ return clr.loadClassWithout(exclude, className);
+ }
+
+ public Class<?> loadClassBefore(
+ ClassLoader stop, String className)
+ throws ClassNotFoundException {
+ return clr.loadClassBefore(stop, className);
+ }
+ };
+ }
+
+ private static class ClassLoaderRepositoryImpl
+ extends ClassLoader implements ClassLoaderRepository {
+ private List<ClassLoader> loaders = newList();
+ {
+ loaders.add(this.getClass().getClassLoader());
+ // We also behave as if the system class loader were in
+ // the repository, since we do nothing to stop delegation
+ // to the parent, which is the system class loader, and
+ // that delegation happens before our findClass is called.
+ }
+
+ void addLoader(ClassLoader loader) {
+ loaders.add(loader);
+ }
+
+ void removeLoader(ClassLoader loader) {
+ if (!loaders.remove(loader))
+ throw new RuntimeException("Loader was not in CLR!");
+ }
+
+ public Class<?> loadClassWithout(
+ ClassLoader exclude, String className)
+ throws ClassNotFoundException {
+ return loadClassWithoutBefore(exclude, null, className);
+ }
+
+ public Class<?> loadClassBefore(ClassLoader stop, String className)
+ throws ClassNotFoundException {
+ return loadClassWithoutBefore(null, stop, className);
+ }
+
+ private Class<?> loadClassWithoutBefore(
+ ClassLoader exclude, ClassLoader stop, String className)
+ throws ClassNotFoundException {
+ for (ClassLoader loader : loaders) {
+ if (loader == exclude)
+ continue;
+ if (loader == stop)
+ break;
+ try {
+ return Class.forName(className, false, loader);
+ } catch (ClassNotFoundException e) {
+ // OK: try others
+ }
+ }
+ throw new ClassNotFoundException(className);
+ }
+
+ @Override
+ protected Class<?> findClass(String className)
+ throws ClassNotFoundException {
+ return loadClassWithout(null, className);
+ }
+ }
+
+ /* There is zero or one ListenerTable per MBean.
+ * The ListenerTable stuff is complicated. We want to rewrite the
+ * source of notifications so that if the source of a notification
+ * from the MBean X is a reference to X itself, it gets replaced
+ * by X's ObjectName. To do this, we wrap the user's listener in
+ * a RewriteListener. But if the same listener is added a second
+ * time (perhaps with a different filter or handback) we must
+ * reuse the same RewriteListener so that the two-argument
+ * removeNotificationListener(ObjectName,NotificationListener) will
+ * correctly remove both listeners. This means we must remember the
+ * mapping from listener to WrappedListener. But if the MBean
+ * discards its listeners (as a result of removeNL or spontaneously)
+ * then we don't want to keep a reference to the WrappedListener.
+ * So we have tons of WeakReferences. The key in the ListenerTable
+ * is an IdentityListener, which wraps the user's listener to ensure
+ * that identity and not equality is used during the lookup, even if
+ * the user's listener has an equals method. The value in the
+ * ListenerTable is a WeakReference wrapping a RewriteListener wrapping
+ * the same IdentityListener. Since the RewriteListener is what is
+ * added to the user's MBean, the WeakReference won't disappear as long
+ * as the MBean still has this listener. And since it references the
+ * IdentityListener, that won't disappear either. But once the
+ * RewriteListener is no longer referenced by the user's MBean,
+ * there's nothing to stop its WeakReference from being cleared,
+ * and then corresponding IdentityListener that is now only weakly
+ * referenced from the key in the table.
+ */
+ private static class ListenerTable
+ extends WeakHashMap<NotificationListener,
+ WeakReference<NotificationListener>> {
+ }
+
+ private static class IdentityListener implements NotificationListener {
+ private final NotificationListener userListener;
+
+ IdentityListener(NotificationListener userListener) {
+ this.userListener = userListener;
+ }
+
+ public void handleNotification(
+ Notification notification, Object handback) {
+ userListener.handleNotification(notification, handback);
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ return (this == o);
+ }
+
+ @Override
+ public int hashCode() {
+ return System.identityHashCode(this);
+ }
+ }
+
+ private static class RewriteListener implements NotificationListener {
+ private final ObjectName name;
+ private final Object userMBean;
+ private final NotificationListener userListener;
+
+ RewriteListener(
+ ObjectName name, Object userMBean,
+ NotificationListener userListener) {
+ this.name = name;
+ this.userMBean = userMBean;
+ this.userListener = userListener;
+ }
+
+ public void handleNotification(
+ Notification notification, Object handback) {
+ if (notification.getSource() == userMBean)
+ notification.setSource(name);
+ userListener.handleNotification(notification, handback);
+ }
+ }
+
+ private NotificationListener wrappedListener(
+ ObjectName name, Object userMBean, NotificationListener userListener)
+ throws InstanceNotFoundException {
+ ListenerTable table = new ListenerTable();
+ ListenerTable oldTable = listenerMap.putIfAbsent(name, table);
+ if (oldTable != null)
+ table = oldTable;
+ NotificationListener identityListener =
+ new IdentityListener(userListener);
+ synchronized (table) {
+ NotificationListener rewriteListener = null;
+ WeakReference<NotificationListener> wr =
+ table.get(identityListener);
+ if (wr != null)
+ rewriteListener = wr.get();
+ if (rewriteListener == null) {
+ rewriteListener = new RewriteListener(
+ name, userMBean, identityListener);
+ wr = new WeakReference<NotificationListener>(rewriteListener);
+ table.put(identityListener, wr);
+ }
+ return rewriteListener;
+ }
+ }
+
+ private DynamicMBean getMBean(ObjectName name)
+ throws InstanceNotFoundException {
+ DynamicMBean mbean = mbeans.get(name);
+ if (mbean == null)
+ throw new InstanceNotFoundException(name.toString());
+ return mbean;
+ }
+
+ private static interface WrapDynamicMBean extends DynamicMBean {
+ public Object getWrappedMBean();
+ }
+
+ private static class StandardWrapper
+ implements WrapDynamicMBean, MBeanRegistration {
+ private final Map<String, AttrMethods> attrMap = newMap();
+ private final Map<String, List<Method>> opMap = newMap();
+ private static class AttrMethods {
+ Method getter, setter;
+ }
+
+ private final Object std;
+
+ StandardWrapper(Object std) throws NotCompliantMBeanException {
+ this.std = std;
+ Class<?> intf = mbeanInterface(std.getClass());
+ try {
+ initMaps(intf);
+ } catch (NotCompliantMBeanException e) {
+ throw e;
+ } catch (Exception e) {
+ NotCompliantMBeanException x =
+ new NotCompliantMBeanException(e.getMessage());
+ x.initCause(e);
+ throw x;
+ }
+ }
+
+ private static Class<?> mbeanInterface(Class<?> c)
+ throws NotCompliantMBeanException {
+ do {
+ Class<?>[] intfs = c.getInterfaces();
+ String intfName = c.getName() + "MBean";
+ for (Class<?> intf : intfs) {
+ if (intf.getName().equals(intfName))
+ return intf;
+ }
+ c = c.getSuperclass();
+ } while (c != null);
+ throw new NotCompliantMBeanException(
+ "Does not match Standard or Dynamic MBean patterns: " +
+ c.getName());
+ }
+
+ private void initMaps(Class<?> intf) throws NotCompliantMBeanException {
+ Method[] methods = intf.getMethods();
+
+ for (Method m : methods) {
+ final String name = m.getName();
+ final int nParams = m.getParameterTypes().length;
+
+ String attrName = "";
+ if (name.startsWith("get"))
+ attrName = name.substring(3);
+ else if (name.startsWith("is")
+ && m.getReturnType() == boolean.class)
+ attrName = name.substring(2);
+
+ if (attrName.length() != 0 && m.getParameterTypes().length == 0
+ && m.getReturnType() != void.class) {
+ // It's a getter
+ // Check we don't have both isX and getX
+ AttrMethods am = attrMap.get(attrName);
+ if (am == null)
+ am = new AttrMethods();
+ else {
+ if (am.getter != null) {
+ final String msg = "Attribute " + attrName +
+ " has more than one getter";
+ throw new NotCompliantMBeanException(msg);
+ }
+ }
+ am.getter = m;
+ attrMap.put(attrName, am);
+ } else if (name.startsWith("set") && name.length() > 3
+ && m.getParameterTypes().length == 1 &&
+ m.getReturnType() == void.class) {
+ // It's a setter
+ attrName = name.substring(3);
+ AttrMethods am = attrMap.get(attrName);
+ if (am == null)
+ am = new AttrMethods();
+ else if (am.setter != null) {
+ final String msg = "Attribute " + attrName +
+ " has more than one setter";
+ throw new NotCompliantMBeanException(msg);
+ }
+ am.setter = m;
+ attrMap.put(attrName, am);
+ } else {
+ // It's an operation
+ List<Method> ops = opMap.get(name);
+ if (ops == null)
+ ops = newList();
+ ops.add(m);
+ opMap.put(name, ops);
+ }
+ }
+ /* Check that getters and setters are consistent. */
+ for (Map.Entry<String, AttrMethods> entry : attrMap.entrySet()) {
+ AttrMethods am = entry.getValue();
+ if (am.getter != null && am.setter != null &&
+ am.getter.getReturnType() != am.setter.getParameterTypes()[0]) {
+ final String msg = "Getter and setter for " + entry.getKey() +
+ " have inconsistent types";
+ throw new NotCompliantMBeanException(msg);
+ }
+ }
+ }
+
+ public Object getAttribute(String attribute)
+ throws AttributeNotFoundException, MBeanException, ReflectionException {
+ AttrMethods am = attrMap.get(attribute);
+ if (am == null || am.getter == null)
+ throw new AttributeNotFoundException(attribute);
+ return invokeMethod(am.getter);
+ }
+
+ public void setAttribute(Attribute attribute)
+ throws AttributeNotFoundException, InvalidAttributeValueException,
+ MBeanException, ReflectionException {
+ String name = attribute.getName();
+ AttrMethods am = attrMap.get(name);
+ if (am == null || am.setter == null)
+ throw new AttributeNotFoundException(name);
+ invokeMethod(am.setter, attribute.getValue());
+ }
+
+ public AttributeList getAttributes(String[] attributes) {
+ AttributeList list = new AttributeList();
+ for (String attr : attributes) {
+ try {
+ list.add(new Attribute(attr, getAttribute(attr)));
+ } catch (Exception e) {
+ // OK: ignore per spec
+ }
+ }
+ return list;
+ }
+
+ public AttributeList setAttributes(AttributeList attributes) {
+ AttributeList list = new AttributeList();
+ // We carefully avoid using any new stuff from AttributeList here!
+ for (Iterator<?> it = attributes.iterator(); it.hasNext(); ) {
+ Attribute attr = (Attribute) it.next();
+ try {
+ setAttribute(attr);
+ list.add(attr);
+ } catch (Exception e) {
+ // OK: ignore per spec
+ }
+ }
+ return list;
+ }
+
+ public Object invoke(String actionName, Object[] params, String[] signature)
+ throws MBeanException, ReflectionException {
+ if (params == null)
+ params = new Object[0];
+ if (signature == null)
+ signature = new String[0];
+ List<Method> methods = opMap.get(actionName);
+ if (methods == null) {
+ Exception x = new NoSuchMethodException(actionName);
+ throw new MBeanException(x);
+ }
+ Method found = null;
+ methodloop:
+ for (Method m : methods) {
+ Class<?>[] msig = m.getParameterTypes();
+ if (msig.length != signature.length)
+ continue methodloop;
+ for (int i = 0; i < msig.length; i++) {
+ if (!msig[i].getName().equals(signature[i]))
+ continue methodloop;
+ }
+ found = m;
+ break methodloop;
+ }
+ if (found == null) {
+ Exception x = new NoSuchMethodException(
+ actionName + Arrays.toString(signature));
+ throw new MBeanException(x);
+ }
+ return invokeMethod(found, params);
+ }
+
+ public MBeanInfo getMBeanInfo() {
+ // Attributes
+ List<MBeanAttributeInfo> attrs = newList();
+ for (Map.Entry<String, AttrMethods> attr : attrMap.entrySet()) {
+ String name = attr.getKey();
+ AttrMethods am = attr.getValue();
+ try {
+ attrs.add(new MBeanAttributeInfo(
+ name, name, am.getter, am.setter));
+ } catch (IntrospectionException e) { // grrr
+ throw new RuntimeException(e);
+ }
+ }
+
+ // Operations
+ List<MBeanOperationInfo> ops = newList();
+ for (Map.Entry<String, List<Method>> op : opMap.entrySet()) {
+ String name = op.getKey();
+ List<Method> methods = op.getValue();
+ for (Method m : methods)
+ ops.add(new MBeanOperationInfo(name, m));
+ }
+
+ // Constructors
+ List<MBeanConstructorInfo> constrs = newList();
+ for (Constructor constr : std.getClass().getConstructors())
+ constrs.add(new MBeanConstructorInfo("Constructor", constr));
+
+ // Notifications
+ MBeanNotificationInfo[] notifs;
+ if (std instanceof NotificationBroadcaster)
+ notifs = ((NotificationBroadcaster) std).getNotificationInfo();
+ else
+ notifs = null;
+
+ String className = std.getClass().getName();
+ return new MBeanInfo(
+ className, className,
+ attrs.toArray(new MBeanAttributeInfo[0]),
+ constrs.toArray(new MBeanConstructorInfo[0]),
+ ops.toArray(new MBeanOperationInfo[0]),
+ notifs);
+ }
+
+ private Object invokeMethod(Method m, Object... args)
+ throws MBeanException, ReflectionException {
+ return invokeSomething(m, std,args);
+ }
+
+ public ObjectName preRegister(MBeanServer server, ObjectName name)
+ throws Exception {
+ return mbeanRegistration(std).preRegister(server, name);
+ }
+
+ public void postRegister(Boolean registrationDone) {
+ mbeanRegistration(std).postRegister(registrationDone);
+ }
+
+ public void preDeregister() throws Exception {
+ mbeanRegistration(std).preDeregister();
+ }
+
+ public void postDeregister() {
+ mbeanRegistration(std).postDeregister();
+ }
+
+ public Object getWrappedMBean() {
+ return std;
+ }
+ }
+
+ private DynamicMBean standardToDynamic(Object std)
+ throws NotCompliantMBeanException {
+ return new StandardWrapper(std);
+ }
+
+// private static class NotifWrapper
+// implements WrapDynamicMBean, NotificationEmitter {
+// private final DynamicMBean mbean;
+//
+// NotifWrapper(DynamicMBean mbean) {
+// this.mbean = mbean;
+// }
+//
+// public Object getAttribute(String attribute)
+// throws AttributeNotFoundException, MBeanException, ReflectionException {
+// return mbean.getAttribute(attribute);
+// }
+//
+// public void setAttribute(Attribute attribute)
+// throws AttributeNotFoundException, InvalidAttributeValueException,
+// MBeanException, ReflectionException {
+// mbean.setAttribute(attribute);
+// }
+//
+// public AttributeList getAttributes(String[] attributes) {
+// return mbean.getAttributes(attributes);
+// }
+//
+// public AttributeList setAttributes(AttributeList attributes) {
+// return mbean.setAttributes(attributes);
+// }
+//
+// public Object invoke(
+// String actionName, Object[] params, String[] signature)
+// throws MBeanException, ReflectionException {
+// return mbean.invoke(actionName, params, signature);
+// }
+//
+// public MBeanInfo getMBeanInfo() {
+// return mbean.getMBeanInfo();
+// }
+//
+// public void removeNotificationListener(
+// NotificationListener listener, NotificationFilter filter, Object handback)
+// throws ListenerNotFoundException {
+// ((NotificationEmitter) mbean).removeNotificationListener(
+// listener, filter, handback);
+// // ClassCastException if MBean is not an emitter
+// }
+//
+// public void addNotificationListener(
+// NotificationListener listener, NotificationFilter filter, Object handback)
+// throws IllegalArgumentException {
+// ((NotificationBroadcaster) mbean).addNotificationListener(
+// listener, filter, handback);
+// }
+//
+// public void removeNotificationListener(NotificationListener listener)
+// throws ListenerNotFoundException {
+// ((NotificationBroadcaster) mbean).removeNotificationListener(listener);
+// }
+//
+// public MBeanNotificationInfo[] getNotificationInfo() {
+// return ((NotificationBroadcaster) mbean).getNotificationInfo();
+// }
+//
+// public Object getWrappedMBean() {
+// return getUserMBean(mbean);
+// }
+// }
+
+ private static Object invokeSomething(
+ AccessibleObject ao, Object target, Object[] args)
+ throws MBeanException, ReflectionException {
+ try {
+ if (ao instanceof Method)
+ return ((Method) ao).invoke(target, args);
+ else
+ return ((Constructor) ao).newInstance(args);
+ } catch (InvocationTargetException e) {
+ try {
+ throw e.getCause();
+ } catch (RuntimeException x) {
+ throw new RuntimeMBeanException(x);
+ } catch (Error x) {
+ throw new RuntimeErrorException(x);
+ } catch (Exception x) {
+ throw new MBeanException(x);
+ } catch (Throwable x) {
+ throw new RuntimeException(x); // neither Error nor Exception!
+ }
+ } catch (Exception e) {
+ throw new ReflectionException(e);
+ }
+ }
+
+ private static Object getUserMBean(DynamicMBean mbean) {
+ if (mbean instanceof WrapDynamicMBean)
+ return ((WrapDynamicMBean) mbean).getWrappedMBean();
+ return mbean;
+ }
+
+ private Object getUserMBean(ObjectName name)
+ throws InstanceNotFoundException {
+ return getUserMBean(getMBean(name));
+ }
+
+ private static final MBeanRegistration noRegistration =
+ new MBeanRegistration() {
+ public ObjectName preRegister(MBeanServer server, ObjectName name) {
+ return name;
+ }
+
+ public void postRegister(Boolean registrationDone) {
+ }
+
+ public void preDeregister() throws Exception {
+ }
+
+ public void postDeregister() {
+ }
+ };
+
+ private static MBeanRegistration mbeanRegistration(Object object) {
+ if (object instanceof MBeanRegistration)
+ return (MBeanRegistration) object;
+ else
+ return noRegistration;
+ }
+
+ private static <E> List<E> newList() {
+ return new ArrayList<E>();
+ }
+
+ private static <K, V> Map<K, V> newMap() {
+ return new HashMap<K, V>();
+ }
+
+ private static <E> Set<E> newSet() {
+ return new HashSet<E>();
+ }
+ }
+}