| /* |
| * Copyright 2007-2008 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 DynamicWrapperMBeanTest |
| * @bug 6624232 6776225 |
| * @summary Test the DynamicWrapperMBean interface |
| * @author Eamonn McManus |
| */ |
| |
| import java.lang.management.ManagementFactory; |
| import javax.annotation.Resource; |
| import javax.management.JMX; |
| import javax.management.ListenerNotFoundException; |
| import javax.management.MBeanNotificationInfo; |
| import javax.management.MBeanServer; |
| import javax.management.Notification; |
| import javax.management.NotificationBroadcaster; |
| import javax.management.NotificationBroadcasterSupport; |
| import javax.management.NotificationEmitter; |
| import javax.management.NotificationFilter; |
| import javax.management.NotificationInfo; |
| import javax.management.NotificationListener; |
| import javax.management.ObjectName; |
| import javax.management.SendNotification; |
| import javax.management.StandardEmitterMBean; |
| import javax.management.StandardMBean; |
| import javax.management.modelmbean.ModelMBeanInfo; |
| import javax.management.modelmbean.ModelMBeanInfoSupport; |
| import javax.management.modelmbean.ModelMBeanOperationInfo; |
| import javax.management.modelmbean.RequiredModelMBean; |
| import static javax.management.StandardMBean.Options; |
| |
| public class DynamicWrapperMBeanTest { |
| private static String failure; |
| |
| public static void main(String[] args) throws Exception { |
| wrapTest(); |
| notifTest(); |
| |
| if (failure == null) |
| System.out.println("TEST PASSED"); |
| else |
| throw new Exception("TEST FAILED: " + failure); |
| } |
| |
| private static final Options wrappedVisOpts = new Options(); |
| private static final Options wrappedInvisOpts = new Options(); |
| static { |
| wrappedVisOpts.setWrappedObjectVisible(true); |
| wrappedInvisOpts.setWrappedObjectVisible(false); |
| } |
| |
| public static interface WrappedMBean { |
| public void sayHello(); |
| } |
| public static class Wrapped implements WrappedMBean { |
| public void sayHello() { |
| System.out.println("Hello"); |
| } |
| } |
| |
| private static void wrapTest() throws Exception { |
| if (Wrapped.class.getClassLoader() == |
| StandardMBean.class.getClassLoader()) { |
| throw new Exception( |
| "TEST ERROR: Resource and StandardMBean have same ClassLoader"); |
| } |
| |
| assertEquals("Options withWrappedObjectVisible(false)", |
| new Options(), wrappedInvisOpts); |
| |
| Wrapped resource = new Wrapped(); |
| |
| StandardMBean visible = |
| new StandardMBean(resource, WrappedMBean.class, wrappedVisOpts); |
| StandardMBean invisible = |
| new StandardMBean(resource, WrappedMBean.class, wrappedInvisOpts); |
| |
| assertEquals("getResource withWrappedObjectVisible(true)", |
| resource, visible.getWrappedObject()); |
| assertEquals("getResource withWrappedObjectVisible(false)", |
| invisible, invisible.getWrappedObject()); |
| |
| System.out.println("===Testing StandardMBean==="); |
| |
| ObjectName visibleName = new ObjectName("a:type=visible"); |
| ObjectName invisibleName = new ObjectName("a:type=invisible"); |
| MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); |
| mbs.registerMBean(visible, visibleName); |
| mbs.registerMBean(invisible, invisibleName); |
| |
| assertEquals("ClassLoader for visible resource", |
| Wrapped.class.getClassLoader(), |
| mbs.getClassLoaderFor(visibleName)); |
| assertEquals("ClassLoader for invisible resource", |
| StandardMBean.class.getClassLoader(), |
| mbs.getClassLoaderFor(invisibleName)); |
| |
| assertEquals("isInstanceOf(WrappedMBean) for visible wrapped", |
| true, mbs.isInstanceOf(visibleName, WrappedMBean.class.getName())); |
| assertEquals("isInstanceOf(WrappedMBean) for invisible wrapped", |
| false, mbs.isInstanceOf(invisibleName, WrappedMBean.class.getName())); |
| assertEquals("isInstanceOf(StandardMBean) for visible wrapped", |
| false, mbs.isInstanceOf(visibleName, StandardMBean.class.getName())); |
| assertEquals("isInstanceOf(StandardMBean) for invisible wrapped", |
| true, mbs.isInstanceOf(invisibleName, StandardMBean.class.getName())); |
| |
| mbs.unregisterMBean(visibleName); |
| mbs.unregisterMBean(invisibleName); |
| |
| System.out.println("===Testing RequiredModelMBean==="); |
| |
| // Godawful Model MBeans... |
| ModelMBeanOperationInfo mmboi = new ModelMBeanOperationInfo( |
| "say hello to the nice man", Wrapped.class.getMethod("sayHello")); |
| ModelMBeanInfo visibleMmbi = new ModelMBeanInfoSupport( |
| Wrapped.class.getName(), "Visible wrapped", null, null, |
| new ModelMBeanOperationInfo[] {mmboi}, null); |
| ModelMBeanInfo invisibleMmbi = new ModelMBeanInfoSupport( |
| Wrapped.class.getName(), "Invisible wrapped", null, null, |
| new ModelMBeanOperationInfo[] {mmboi}, null); |
| RequiredModelMBean visibleRmmb = new RequiredModelMBean(visibleMmbi); |
| RequiredModelMBean invisibleRmmb = new RequiredModelMBean(invisibleMmbi); |
| visibleRmmb.setManagedResource(resource, "VisibleObjectReference"); |
| invisibleRmmb.setManagedResource(resource, "ObjectReference"); |
| |
| mbs.registerMBean(visibleRmmb, visibleName); |
| mbs.registerMBean(invisibleRmmb, invisibleName); |
| |
| assertEquals("ClassLoader for visible wrapped", |
| Wrapped.class.getClassLoader(), |
| mbs.getClassLoaderFor(visibleName)); |
| assertEquals("ClassLoader for invisible wrapped", |
| StandardMBean.class.getClassLoader(), |
| mbs.getClassLoaderFor(invisibleName)); |
| |
| assertEquals("isInstanceOf(WrappedMBean) for visible resource", |
| true, mbs.isInstanceOf(visibleName, WrappedMBean.class.getName())); |
| assertEquals("isInstanceOf(WrappedMBean) for invisible resource", |
| false, mbs.isInstanceOf(invisibleName, WrappedMBean.class.getName())); |
| assertEquals("isInstanceOf(RequiredModelMBean) for visible resource", |
| false, mbs.isInstanceOf(visibleName, RequiredModelMBean.class.getName())); |
| assertEquals("isInstanceOf(RequiredModelMBean) for invisible resource", |
| true, mbs.isInstanceOf(invisibleName, RequiredModelMBean.class.getName())); |
| |
| mbs.unregisterMBean(visibleName); |
| mbs.unregisterMBean(invisibleName); |
| } |
| |
| private static enum WrapType { |
| NBS("NotificationBroadcasterSupport"), |
| INJ("@Resource SendNotification"), |
| STD_MBEAN_NBS("StandardMBean delegating to NotificationBroadcasterSupport"), |
| STD_MBEAN_INJ("StandardMBean delegating to @Resource SendNotification"), |
| STD_MBEAN_SUB_NBS("StandardMBean subclass implementing NotificationBroadcaster"), |
| STD_MBEAN_SUB_INJ("StandardMBean subclass with @Resource SendNotification"), |
| STD_EMIT_MBEAN_NBS("StandardEmitterMBean delegating to NotificationBroadcasterSupport"), |
| STD_EMIT_MBEAN_INJ("StandardEmitterMBean delegating to @Resource SendNotification"), |
| STD_EMIT_MBEAN_SUB("StandardEmitterMBean subclass"), |
| STD_EMIT_MBEAN_SUB_INJ("StandardEmitterMBean subclass with @Resource SendNotification"); |
| |
| WrapType(String s) { |
| this.s = s; |
| } |
| |
| @Override |
| public String toString() { |
| return s; |
| } |
| |
| private final String s; |
| } |
| |
| @NotificationInfo( |
| types = {"foo", "bar"} |
| ) |
| public static interface BroadcasterMBean { |
| public void send(Notification n); |
| } |
| |
| public static class Broadcaster |
| extends NotificationBroadcasterSupport implements BroadcasterMBean { |
| public void send(Notification n) { |
| super.sendNotification(n); |
| } |
| } |
| |
| public static interface SendNotifMBean extends BroadcasterMBean { |
| } |
| |
| public static class SendNotif implements SendNotifMBean { |
| @Resource |
| private volatile SendNotification sendNotif; |
| |
| public void send(Notification n) { |
| sendNotif.sendNotification(n); |
| } |
| } |
| |
| public static class StdBroadcaster |
| extends StandardMBean |
| implements BroadcasterMBean, NotificationBroadcaster { |
| private final NotificationBroadcasterSupport nbs = |
| new NotificationBroadcasterSupport(); |
| |
| public StdBroadcaster() throws Exception { |
| super(BroadcasterMBean.class); |
| } |
| |
| public void send(Notification n) { |
| nbs.sendNotification(n); |
| } |
| |
| public void addNotificationListener(NotificationListener listener, |
| NotificationFilter filter, Object handback) { |
| nbs.addNotificationListener(listener, filter, handback); |
| } |
| |
| public MBeanNotificationInfo[] getNotificationInfo() { |
| return null; |
| } |
| |
| public void removeNotificationListener(NotificationListener listener) |
| throws ListenerNotFoundException { |
| nbs.removeNotificationListener(listener); |
| } |
| } |
| |
| public static class StdSendNotif |
| extends StandardMBean implements SendNotifMBean { |
| @Resource |
| private volatile SendNotification sendNotif; |
| |
| public StdSendNotif() throws Exception { |
| super(SendNotifMBean.class); |
| } |
| |
| public void send(Notification n) { |
| sendNotif.sendNotification(n); |
| } |
| } |
| |
| public static class StdEmitterBroadcaster // :-) |
| extends StandardEmitterMBean |
| implements BroadcasterMBean { |
| |
| public StdEmitterBroadcaster() throws Exception { |
| super(BroadcasterMBean.class, null); |
| } |
| |
| public void send(Notification n) { |
| super.sendNotification(n); |
| } |
| } |
| |
| // This case is unlikely - if you're using @Resource SendNotification |
| // then there's no point in using StandardEmitterMBean, since |
| // StandardMBean would suffice. |
| public static class StdEmitterSendNotif |
| extends StandardEmitterMBean implements SendNotifMBean { |
| @Resource |
| private volatile SendNotification sendNotif; |
| |
| public StdEmitterSendNotif() { |
| super(SendNotifMBean.class, null); |
| } |
| |
| public void send(Notification n) { |
| sendNotif.sendNotification(n); |
| } |
| } |
| |
| // Test that JMX.isNotificationSource and |
| // mbs.isInstanceOf("NotificationBroadcaster") work correctly even when |
| // the MBean is a broadcaster by virtue of its wrapped resource. |
| // Test that we find the MBeanNotificationInfo[] from the @NotificationInfo |
| // annotation on BroadcasterMBean. We cover a large number of different |
| // MBean types, but all ultimately implement that interface. |
| private static void notifTest() throws Exception { |
| System.out.println("===Testing notification senders==="); |
| |
| for (WrapType wrapType : WrapType.values()) { |
| System.out.println("---" + wrapType); |
| |
| final Object mbean; |
| |
| switch (wrapType) { |
| case NBS: |
| // An MBean that extends NotificationBroadcasterSupport |
| mbean = new Broadcaster(); |
| break; |
| case INJ: |
| // An MBean that injects SendNotification |
| mbean = new SendNotif(); |
| break; |
| case STD_MBEAN_NBS: |
| // A StandardMBean that delegates to a NotificationBroadcasterSupport |
| mbean = new StandardMBean( |
| new Broadcaster(), BroadcasterMBean.class, wrappedVisOpts); |
| break; |
| case STD_MBEAN_INJ: |
| // A StandardMBean that delegates to an object that injects |
| // SendNotification |
| mbean = new StandardMBean( |
| new SendNotif(), BroadcasterMBean.class, wrappedVisOpts); |
| break; |
| case STD_EMIT_MBEAN_NBS: { |
| // A StandardEmitterMBean that delegates to a NotificationBroadcasterSupport |
| Broadcaster broadcaster = new Broadcaster(); |
| mbean = new StandardEmitterMBean( |
| broadcaster, BroadcasterMBean.class, wrappedVisOpts, |
| broadcaster); |
| break; |
| } |
| case STD_EMIT_MBEAN_INJ: { |
| // A StandardEmitterMBean that delegates to an object that injects |
| // SendNotification |
| SendNotif sendNotif = new SendNotif(); |
| mbean = new StandardEmitterMBean( |
| sendNotif, BroadcasterMBean.class, wrappedVisOpts, |
| null); |
| break; |
| } |
| case STD_MBEAN_SUB_NBS: |
| // A subclass of StandardMBean that implements NotificationBroadcaster |
| mbean = new StdBroadcaster(); |
| break; |
| case STD_MBEAN_SUB_INJ: |
| // A subclass of StandardMBean that injects SendNotification |
| mbean = new StdSendNotif(); |
| break; |
| case STD_EMIT_MBEAN_SUB: |
| // A subclass of StandardEmitterMBean |
| mbean = new StdEmitterBroadcaster(); |
| break; |
| case STD_EMIT_MBEAN_SUB_INJ: |
| // A subclass of StandardEmitterMBean that injects SendNotification |
| // (which is a rather strange thing to do and probably a user |
| // misunderstanding but we should do the right thing anyway). |
| mbean = new StdEmitterSendNotif(); |
| break; |
| default: |
| throw new AssertionError(); |
| } |
| |
| MBeanServer mbs = ManagementFactory.getPlatformMBeanServer(); |
| |
| final ObjectName name = new ObjectName("a:type=Sender"); |
| mbs.registerMBean(mbean, name); |
| boolean isBroadcaster = mbs.isInstanceOf( |
| name, NotificationBroadcaster.class.getName()); |
| assertEquals("JMX.isNotificationSource(mbean)", |
| true, JMX.isNotificationSource(mbean)); |
| assertEquals("isInstanceOf(NotificationBroadcaster)", |
| true, isBroadcaster); |
| MBeanNotificationInfo[] mbnis = |
| mbs.getMBeanInfo(name).getNotifications(); |
| assertEquals("MBeanNotificationInfo not empty", |
| true, (mbnis.length > 0)); |
| |
| mbs.unregisterMBean(name); |
| } |
| } |
| |
| private static void assertEquals(String what, Object expect, Object actual) { |
| if (equal(expect, actual)) |
| System.out.println("OK: " + what + " = " + expect); |
| else |
| fail(what + " should be " + expect + ", is " + actual); |
| } |
| |
| private static boolean equal(Object x, Object y) { |
| if (x == y) |
| return true; |
| if (x == null || y == null) |
| return false; |
| return x.equals(y); |
| } |
| |
| private static void fail(String why) { |
| failure = why; |
| System.out.println("FAIL: " + why); |
| } |
| } |
