| /* |
| * Copyright (c) 2007, 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. |
| * |
| * 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. |
| */ |
| |
| 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>(); |
| } |
| } |
| } |
