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