| /* |
| * 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. |
| */ |
| |
| /* |
| * @test %M% %I% |
| * @bug 6323980 |
| * @summary Test resource injection via @Resource |
| * @author Eamonn McManus |
| * @run main/othervm -ea ResourceInjectionTest |
| */ |
| |
| import java.io.File; |
| import java.io.PrintWriter; |
| import java.io.Serializable; |
| import java.lang.annotation.Retention; |
| import java.lang.annotation.RetentionPolicy; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.lang.reflect.Modifier; |
| import java.util.Arrays; |
| import javax.annotation.Resource; |
| import javax.management.Attribute; |
| import javax.management.AttributeList; |
| import javax.management.AttributeNotFoundException; |
| import javax.management.DynamicMBean; |
| import javax.management.InstanceNotFoundException; |
| import javax.management.MBean; |
| import javax.management.MBeanException; |
| import javax.management.MBeanInfo; |
| import javax.management.MBeanRegistrationException; |
| import javax.management.MBeanServer; |
| import javax.management.MBeanServerFactory; |
| import javax.management.MXBean; |
| import javax.management.MalformedObjectNameException; |
| import javax.management.ManagedAttribute; |
| import javax.management.ManagedOperation; |
| import javax.management.NotCompliantMBeanException; |
| import javax.management.Notification; |
| import javax.management.NotificationEmitter; |
| import javax.management.NotificationListener; |
| import javax.management.ObjectName; |
| import javax.management.ReflectionException; |
| import javax.management.SendNotification; |
| import javax.management.StandardEmitterMBean; |
| import javax.management.StandardMBean; |
| import javax.management.openmbean.MXBeanMappingFactory; |
| |
| public class ResourceInjectionTest { |
| private static MBeanServer mbs; |
| private static final ObjectName objectName; |
| static { |
| try { |
| objectName = new ObjectName("test:type=Test"); |
| } catch (MalformedObjectNameException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| /* This is somewhat nasty. In the current state of affairs, a |
| * StandardEmitterMBean can only get the |
| * MBeanServer to rewrite the source of a Notification from |
| * the originating object's reference to its ObjectName IF |
| * StandardEmitterMBean.getResource() returns a reference to the |
| * wrapped object. By default it doesn't, and you need to specify |
| * the option below to make it do so. We may hope that this is |
| * obscure enough for users to run into it rarely if ever. |
| */ |
| private static final StandardMBean.Options withWrappedVisible; |
| private static final StandardMBean.Options withWrappedVisibleMX; |
| static { |
| withWrappedVisible = new StandardMBean.Options(); |
| withWrappedVisible.setWrappedObjectVisible(true); |
| withWrappedVisibleMX = withWrappedVisible.clone(); |
| withWrappedVisibleMX.setMXBeanMappingFactory(MXBeanMappingFactory.DEFAULT); |
| } |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| private static @interface ExpectException { |
| Class<? extends Exception> value(); |
| } |
| |
| public static void main(String[] args) throws Exception { |
| if (!ResourceInjectionTest.class.desiredAssertionStatus()) |
| throw new Exception("Test must be run with -ea"); |
| |
| File policyFile = File.createTempFile("jmxperms", ".policy"); |
| policyFile.deleteOnExit(); |
| PrintWriter pw = new PrintWriter(policyFile); |
| pw.println("grant {"); |
| pw.println(" permission javax.management.MBeanPermission \"*\", \"*\";"); |
| pw.println(" permission javax.management.MBeanServerPermission \"*\";"); |
| pw.println(" permission javax.management.MBeanTrustPermission \"*\";"); |
| pw.println("};"); |
| pw.close(); |
| |
| System.setProperty("java.security.policy", policyFile.getAbsolutePath()); |
| System.setSecurityManager(new SecurityManager()); |
| |
| String failure = null; |
| |
| for (Method m : ResourceInjectionTest.class.getDeclaredMethods()) { |
| if (Modifier.isStatic(m.getModifiers()) && |
| m.getName().startsWith("test") && |
| m.getParameterTypes().length == 0) { |
| ExpectException expexc = m.getAnnotation(ExpectException.class); |
| mbs = MBeanServerFactory.newMBeanServer(); |
| 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); |
| } |
| } |
| } |
| } |
| if (failure == null) |
| System.out.println("TEST PASSED"); |
| else |
| throw new Exception("TEST FAILED: " + failure); |
| } |
| |
| private static interface Send { |
| public void send(); |
| } |
| |
| // Test @Resource in MBean defined by annotations |
| |
| @MBean |
| public static class Annotated { |
| @Resource |
| private volatile MBeanServer mbeanServer; |
| @Resource |
| private volatile ObjectName myName; |
| |
| @ManagedAttribute |
| public ObjectName getMyName() { |
| return myName; |
| } |
| |
| @ManagedOperation |
| public void unregisterSelf() |
| throws InstanceNotFoundException, MBeanRegistrationException { |
| mbeanServer.unregisterMBean(myName); |
| } |
| } |
| |
| private static void testAnnotated() throws Exception { |
| testMBean(new Annotated()); |
| } |
| |
| private static void testAnnotatedWrapped() throws Exception { |
| testMBean(new StandardMBean(new Annotated(), null)); |
| } |
| |
| @MBean |
| public static class AnnotatedSend extends Annotated implements Send { |
| @Resource |
| private volatile SendNotification sender; |
| |
| @ManagedOperation |
| public void send() { |
| sender.sendNotification(new Notification("type", this, 0L)); |
| } |
| } |
| |
| private static void testAnnotatedSend() throws Exception { |
| testMBean(new AnnotatedSend()); |
| } |
| |
| private static void testAnnotatedSendWrapped() throws Exception { |
| testMBean(new StandardEmitterMBean( |
| new AnnotatedSend(), null, withWrappedVisible, null)); |
| } |
| |
| // Test @Resource in MXBean defined by annotations |
| |
| @MXBean |
| public static class AnnotatedMX { |
| @Resource |
| private volatile MBeanServer mbeanServer; |
| @Resource |
| private volatile ObjectName myName; |
| |
| @ManagedAttribute |
| public ObjectName getMyName() { |
| return myName; |
| } |
| |
| @ManagedOperation |
| public void unregisterSelf() |
| throws InstanceNotFoundException, MBeanRegistrationException { |
| mbeanServer.unregisterMBean(myName); |
| } |
| } |
| |
| private static void testAnnotatedMX() throws Exception { |
| testMBean(new AnnotatedMX()); |
| } |
| |
| private static void testAnnotatedMXWrapped() throws Exception { |
| testMBean(new StandardMBean(new AnnotatedMX(), null, true)); |
| } |
| |
| public static class AnnotatedMXSend extends AnnotatedMX implements Send { |
| @Resource |
| private volatile SendNotification sender; |
| |
| @ManagedOperation |
| public void send() { |
| sender.sendNotification(new Notification("type", this, 0L)); |
| } |
| } |
| |
| private static void testAnnotatedMXSend() throws Exception { |
| testMBean(new AnnotatedMXSend()); |
| } |
| |
| private static void testAnnotatedMXSendWrapped() throws Exception { |
| testMBean(new StandardEmitterMBean( |
| new AnnotatedMXSend(), null, withWrappedVisibleMX, null)); |
| } |
| |
| // Test @Resource in Standard MBean |
| |
| public static interface SimpleStandardMBean { |
| public ObjectName getMyName(); |
| public void unregisterSelf() throws Exception; |
| } |
| |
| public static class SimpleStandard implements SimpleStandardMBean { |
| @Resource(type = MBeanServer.class) |
| private volatile Object mbeanServer; |
| @Resource(type = ObjectName.class) |
| private volatile Object myName; |
| |
| public ObjectName getMyName() { |
| return (ObjectName) myName; |
| } |
| |
| public void unregisterSelf() throws Exception { |
| ((MBeanServer) mbeanServer).unregisterMBean(getMyName()); |
| } |
| } |
| |
| private static void testStandard() throws Exception { |
| testMBean(new SimpleStandard()); |
| } |
| |
| private static void testStandardWrapped() throws Exception { |
| testMBean(new StandardMBean(new SimpleStandard(), SimpleStandardMBean.class)); |
| } |
| |
| public static interface SimpleStandardSendMBean extends SimpleStandardMBean { |
| public void send(); |
| } |
| |
| public static class SimpleStandardSend |
| extends SimpleStandard implements SimpleStandardSendMBean { |
| @Resource(type = SendNotification.class) |
| private volatile Object sender; |
| |
| public void send() { |
| ((SendNotification) sender).sendNotification( |
| new Notification("type", this, 0L)); |
| } |
| } |
| |
| private static void testStandardSend() throws Exception { |
| testMBean(new SimpleStandardSend()); |
| } |
| |
| private static void testStandardSendWrapped() throws Exception { |
| testMBean(new StandardEmitterMBean( |
| new SimpleStandardSend(), SimpleStandardSendMBean.class, |
| withWrappedVisible, null)); |
| } |
| |
| // Test @Resource in MXBean |
| |
| public static interface SimpleMXBean { |
| public ObjectName getMyName(); |
| public void unregisterSelf() throws Exception; |
| } |
| |
| public static class SimpleMX implements SimpleMXBean { |
| @Resource(type = MBeanServer.class) |
| private volatile Object mbeanServer; |
| @Resource(type = ObjectName.class) |
| private volatile Object myName; |
| |
| public ObjectName getMyName() { |
| return (ObjectName) myName; |
| } |
| |
| public void unregisterSelf() throws Exception { |
| ((MBeanServer) mbeanServer).unregisterMBean(getMyName()); |
| } |
| } |
| |
| private static void testMX() throws Exception { |
| testMBean(new SimpleMX()); |
| } |
| |
| private static void testMXWrapped() throws Exception { |
| testMBean(new StandardMBean(new SimpleMX(), SimpleMXBean.class, true)); |
| } |
| |
| public static interface SimpleMXBeanSend extends SimpleMXBean { |
| public void send(); |
| } |
| |
| public MBeanServer getMbs() { |
| return mbs; |
| } |
| |
| public static class SimpleMXSend extends SimpleMX implements SimpleMXBeanSend { |
| @Resource(type = SendNotification.class) |
| private volatile Object sender; |
| |
| public void send() { |
| ((SendNotification) sender).sendNotification( |
| new Notification("type", this, 0L)); |
| } |
| } |
| |
| private static void testMXSend() throws Exception { |
| testMBean(new SimpleMXSend()); |
| } |
| |
| private static void testMXSendWrapped() throws Exception { |
| testMBean(new StandardEmitterMBean( |
| new SimpleMXSend(), SimpleMXBeanSend.class, |
| withWrappedVisibleMX, null)); |
| } |
| |
| // Test @Resource in Dynamic MBean |
| |
| private static class SimpleDynamic implements DynamicMBean { |
| private MBeanServer mbeanServer; |
| private ObjectName myName; |
| |
| @Resource |
| private synchronized void setMBeanServer(MBeanServer mbs) { |
| mbeanServer = mbs; |
| } |
| |
| @Resource(type = ObjectName.class) |
| private synchronized void setObjectName(Serializable name) { |
| myName = (ObjectName) name; |
| } |
| |
| public synchronized Object getAttribute(String attribute) |
| throws AttributeNotFoundException { |
| if (attribute.equals("MyName")) |
| return myName; |
| throw new AttributeNotFoundException(attribute); |
| } |
| |
| public void setAttribute(Attribute attribute) |
| throws AttributeNotFoundException { |
| throw new AttributeNotFoundException(attribute.getName()); |
| } |
| |
| public synchronized AttributeList getAttributes(String[] attributes) { |
| AttributeList list = new AttributeList(); |
| for (String name : attributes) { |
| if (name.equals("MyName")) |
| list.add(new Attribute("MyName", myName)); |
| } |
| return list; |
| } |
| |
| public AttributeList setAttributes(AttributeList attributes) { |
| return new AttributeList(); |
| } |
| |
| public synchronized Object invoke( |
| String actionName, Object[] params, String[] signature) |
| throws MBeanException, ReflectionException { |
| if (actionName.equals("unregisterSelf") && |
| (params == null || params.length == 0) && |
| (signature == null || signature.length == 0)) { |
| try { |
| mbeanServer.unregisterMBean(myName); |
| return null; |
| } catch (Exception x) { |
| throw new MBeanException(x); |
| } |
| } else { |
| Exception x = new NoSuchMethodException( |
| actionName + Arrays.toString(signature)); |
| throw new MBeanException(x); |
| } |
| } |
| |
| public MBeanInfo getMBeanInfo() { |
| DynamicMBean mbean = new StandardMBean( |
| new SimpleStandard(), SimpleStandardMBean.class, false); |
| return mbean.getMBeanInfo(); |
| } |
| } |
| |
| private static void testDynamic() throws Exception { |
| testMBean(new SimpleDynamic()); |
| } |
| |
| private static class SimpleDynamicSend extends SimpleDynamic { |
| private SendNotification sender; |
| |
| @Resource |
| private synchronized void setSender(SendNotification sender) { |
| this.sender = sender; |
| } |
| |
| @Override |
| public synchronized Object invoke( |
| String actionName, Object[] params, String[] signature) |
| throws MBeanException, ReflectionException { |
| if (actionName.equals("send")) { |
| sender.sendNotification(new Notification("type", this, 0L)); |
| return null; |
| } else |
| return super.invoke(actionName, params, signature); |
| } |
| } |
| |
| private static void testDynamicSend() throws Exception { |
| testMBean(new SimpleDynamicSend()); |
| } |
| |
| // Test that @Resource classes don't have to be public |
| // They can even be defined within methods! |
| // But you can't have any @ManagedAttributes or @ManagedOperations |
| // in such MBeans so their utility is limited. |
| |
| private static void testNonPublic() throws Exception { |
| @MBean |
| class NonPublic { |
| @Resource |
| ObjectName myName; |
| } |
| assert !Modifier.isPublic(NonPublic.class.getModifiers()); |
| NonPublic mbean = new NonPublic(); |
| mbs.registerMBean(mbean, objectName); |
| assert objectName.equals(mbean.myName); |
| } |
| |
| // Test inheritance and multiple injections of the same value |
| |
| private static class ManyResources extends AnnotatedSend { |
| @Resource |
| private volatile ObjectName myName; // same name as in parent! |
| @Resource(type=ObjectName.class) |
| private volatile Object myOtherName; |
| private volatile ObjectName myThirdName; |
| private volatile ObjectName myFourthName; |
| private volatile int methodCalls; |
| @Resource |
| private volatile SendNotification send1; |
| @Resource(type = SendNotification.class) |
| private volatile Object send2; |
| |
| @Resource |
| void setMyName(ObjectName name) { |
| myThirdName = name; |
| methodCalls++; |
| } |
| |
| @Resource(type=ObjectName.class) |
| private void setMyNameAgain(ObjectName name) { |
| myFourthName = name; |
| methodCalls++; |
| } |
| |
| void check() { |
| assert objectName.equals(myName) : myName; |
| for (ObjectName name : new ObjectName[] { |
| (ObjectName)myOtherName, myThirdName, myFourthName |
| }) { |
| assert myName == name : name; |
| } |
| assert methodCalls == 2 : methodCalls; |
| assert send1 != null && send2 == send1; |
| } |
| } |
| |
| private static void testManyResources() throws Exception { |
| ManyResources mr = new ManyResources(); |
| testMBean(mr); |
| mr.check(); |
| } |
| |
| // Test that method override doesn't lead to multiple calls of the same method |
| |
| private static class ManyResourcesSub extends ManyResources { |
| private boolean called; |
| |
| @Override |
| @Resource |
| void setMyName(ObjectName name) { |
| super.setMyName(name); |
| called = true; |
| } |
| |
| void check2() { |
| assert called; |
| } |
| } |
| |
| private static void testOverride() throws Exception { |
| ManyResourcesSub mrs = new ManyResourcesSub(); |
| testMBean(mrs); |
| mrs.check(); |
| mrs.check2(); |
| } |
| |
| // Test that @Resource is illegal on static fields |
| |
| @MBean |
| public static class StaticResource { |
| @Resource |
| private static ObjectName name; |
| } |
| |
| @ExpectException(NotCompliantMBeanException.class) |
| private static void testStaticResource() throws Exception { |
| testMBean(new StaticResource()); |
| } |
| |
| // Test that @Resource is illegal on static methods |
| |
| @MBean |
| public static class StaticResourceMethod { |
| @Resource |
| private static void setObjectName(ObjectName name) {} |
| } |
| |
| @ExpectException(NotCompliantMBeanException.class) |
| private static void testStaticResourceMethod() throws Exception { |
| testMBean(new StaticResourceMethod()); |
| } |
| |
| // Test that @Resource is illegal on methods that don't return void |
| |
| @MBean |
| public static class NonVoidMethod { |
| @Resource |
| private String setObjectName(ObjectName name) { |
| return "oops"; |
| } |
| } |
| |
| @ExpectException(NotCompliantMBeanException.class) |
| private static void testNonVoidMethod() throws Exception { |
| testMBean(new NonVoidMethod()); |
| } |
| |
| // Test that @Resource is illegal on methods with no arguments |
| |
| @MBean |
| public static class NoArgMethod { |
| @Resource(type=ObjectName.class) |
| private void setObjectName() {} |
| } |
| |
| @ExpectException(NotCompliantMBeanException.class) |
| private static void testNoArgMethod() throws Exception { |
| testMBean(new NoArgMethod()); |
| } |
| |
| // Test that @Resource is illegal on methods with more than one argument |
| |
| @MBean |
| public static class MultiArgMethod { |
| @Resource |
| private void setObjectName(ObjectName name, String what) {} |
| } |
| |
| @ExpectException(NotCompliantMBeanException.class) |
| private static void testMultiArgMethod() throws Exception { |
| testMBean(new MultiArgMethod()); |
| } |
| |
| private static class CountListener implements NotificationListener { |
| volatile int count; |
| public void handleNotification(Notification notification, Object handback) { |
| count++; |
| } |
| } |
| |
| private static void testMBean(Object mbean) throws Exception { |
| mbs.registerMBean(mbean, objectName); |
| |
| final ObjectName name = (ObjectName) mbs.getAttribute(objectName, "MyName"); |
| assert objectName.equals(name) : name; |
| |
| if (mbean instanceof Send || mbean instanceof NotificationEmitter) { |
| assert mbs.isInstanceOf(name, NotificationEmitter.class.getName()); |
| CountListener countL = new CountListener(); |
| mbs.addNotificationListener(name, countL, null, null); |
| NotificationListener checkSource = new NotificationListener() { |
| public void handleNotification(Notification n, Object h) { |
| assert n.getSource().equals(name) : n.getSource(); |
| } |
| }; |
| mbs.addNotificationListener(name, checkSource, null, null); |
| mbs.invoke(objectName, "send", null, null); |
| assert countL.count == 1; |
| mbs.removeNotificationListener(name, checkSource); |
| mbs.removeNotificationListener(name, countL, null, null); |
| } |
| |
| mbs.invoke(objectName, "unregisterSelf", null, null); |
| assert !mbs.isRegistered(objectName); |
| } |
| } |
