/**
  * Returns a string array containing the default JMX domains of all available MBeanServers in this
  * JVM.
  *
  * @return a string array of JMX default domains
  */
 public static String[] getMBeanServerDomains() {
   Set<String> domains = new HashSet<String>();
   for (MBeanServer mbs : MBeanServerFactory.findMBeanServer(null)) {
     String domain = mbs.getDefaultDomain();
     if (domain == null) domain = "DefaultDomain";
     domains.add(domain);
   }
   return domains.toArray(new String[domains.size()]);
 }
 public static void main(String[] args) throws Exception {
   MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
   final Boolean isNotificationSupported =
       AccessController.doPrivileged(
           new PrivilegedAction<Boolean>() {
             public Boolean run() {
               try {
                 Class cl = Class.forName("sun.management.VMManagementImpl");
                 Field f = cl.getDeclaredField("gcNotificationSupport");
                 f.setAccessible(true);
                 return f.getBoolean(null);
               } catch (ClassNotFoundException e) {
                 return false;
               } catch (NoSuchFieldException e) {
                 return false;
               } catch (IllegalAccessException e) {
                 return false;
               }
             }
           });
   if (!isNotificationSupported) {
     System.out.println("GC Notification not supported by the JVM, test skipped");
     return;
   }
   final ObjectName gcMXBeanPattern = new ObjectName("java.lang:type=GarbageCollector,*");
   Set<ObjectName> names = mbs.queryNames(gcMXBeanPattern, null);
   if (names.isEmpty()) throw new Exception("Test incorrect: no GC MXBeans");
   number = names.size();
   for (ObjectName n : names) {
     if (mbs.isInstanceOf(n, "javax.management.NotificationEmitter")) {
       listenerInvoked.put(n.getCanonicalName(), null);
       GcListener listener = new GcListener();
       mbs.addNotificationListener(n, listener, null, null);
     }
   }
   // Invocation of System.gc() to trigger major GC
   System.gc();
   // Allocation of many short living and small objects to trigger minor GC
   Object data[] = new Object[32];
   for (int i = 0; i < 100000000; i++) {
     data[i % 32] = new int[8];
   }
   int wakeup = 0;
   synchronized (synchronizer) {
     while (count != number) {
       synchronizer.wait(10000);
       wakeup++;
       if (wakeup > 10) break;
     }
   }
   for (GarbageCollectionNotificationInfo notif : listenerInvoked.values()) {
     checkGarbageCollectionNotificationInfoContent(notif);
   }
   System.out.println("Test passed");
 }
 private static void checkPlatformMBeans() throws Exception {
   MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
   Set<ObjectName> mbeanNames = mbs.queryNames(null, null);
   for (ObjectName name : mbeanNames) {
     if (!mbs.isInstanceOf(name, NotificationBroadcaster.class.getName())) {
       System.out.println(name + ": not a NotificationBroadcaster");
     } else {
       MBeanInfo mbi = mbs.getMBeanInfo(name);
       check(name.toString(), mbi.getNotifications());
     }
   }
 }
Esempio n. 4
0
  public static void main(String[] args) throws Exception {
    System.out.println(
        "Test that target MBean class loader is used " + "before JMX Remote API class loader");

    ClassLoader jmxRemoteClassLoader = JMXServiceURL.class.getClassLoader();
    if (jmxRemoteClassLoader == null) {
      System.out.println(
          "JMX Remote API loaded by bootstrap " + "class loader, this test is irrelevant");
      return;
    }
    if (!(jmxRemoteClassLoader instanceof URLClassLoader)) {
      System.out.println("TEST INVALID: JMX Remote API not loaded by " + "URLClassLoader");
      System.exit(1);
    }

    URLClassLoader jrcl = (URLClassLoader) jmxRemoteClassLoader;
    URL[] urls = jrcl.getURLs();
    PrivateMLet mlet = new PrivateMLet(urls, null, false);
    Class shadowClass = mlet.loadClass(JMXServiceURL.class.getName());
    if (shadowClass == JMXServiceURL.class) {
      System.out.println("TEST INVALID: MLet got original " + "JMXServiceURL not shadow");
      System.exit(1);
    }

    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    mbs.registerMBean(mlet, mletName);

    final String[] protos = {"rmi", "iiop", "jmxmp"};
    boolean ok = true;
    for (int i = 0; i < protos.length; i++) {
      try {
        ok &= test(protos[i], mbs);
      } catch (Exception e) {
        System.out.println("TEST FAILED WITH EXCEPTION:");
        e.printStackTrace(System.out);
        ok = false;
      }
    }

    if (ok) System.out.println("Test passed");
    else {
      System.out.println("TEST FAILED");
      System.exit(1);
    }
  }
 private static void test(int testno) throws Exception {
   // com.sun.jmx.trace.TraceImplementation.init(2);
   Resource resource = new Resource();
   Class resourceClass = Resource.class;
   Class rmmbClass = RequiredModelMBean.class;
   Method setManagedResource =
       rmmbClass.getMethod("setManagedResource", new Class[] {Object.class, String.class});
   Method sendNotification =
       rmmbClass.getMethod("sendNotification", new Class[] {Notification.class});
   Method addAttributeChangeNL =
       rmmbClass.getMethod(
           "addAttributeChangeNotificationListener",
           new Class[] {NotificationListener.class, String.class, Object.class});
   Method getArray = resourceClass.getMethod("getArray", new Class[0]);
   Method getNumber = resourceClass.getMethod("getNumber", new Class[0]);
   Method setNumber = resourceClass.getMethod("setNumber", new Class[] {Integer.TYPE});
   Method tweakArray = resourceClass.getMethod("tweakArray", new Class[] {Object[].class});
   Method addOne = resourceClass.getMethod("addOne", new Class[] {Integer.TYPE});
   MBeanServer mbs = MBeanServerFactory.newMBeanServer();
   ObjectName on = new ObjectName("a:b=c");
   Descriptor attrDescr = new DescriptorSupport();
   attrDescr.setField("name", "Array");
   attrDescr.setField("descriptorType", "attribute");
   attrDescr.setField("getMethod", "getArray");
   ModelMBeanAttributeInfo attrInfo =
       new ModelMBeanAttributeInfo("Array", "array attr", getArray, null, attrDescr);
   Descriptor attrDescr2 = new DescriptorSupport();
   attrDescr2.setField("name", "Number");
   attrDescr2.setField("descriptorType", "attribute");
   attrDescr2.setField("getMethod", "getNumber");
   attrDescr2.setField("setMethod", "setNumber");
   ModelMBeanAttributeInfo attrInfo2 =
       new ModelMBeanAttributeInfo("Number", "number attr", getNumber, setNumber, attrDescr2);
   Descriptor attrDescr3 = new DescriptorSupport();
   attrDescr3.setField("name", "Local");
   attrDescr3.setField("descriptorType", "attribute");
   attrDescr3.setField("currencyTimeLimit", "" + Integer.MAX_VALUE);
   ModelMBeanAttributeInfo attrInfo3 =
       new ModelMBeanAttributeInfo(
           "Local", "java.lang.String", "local attr", true, true, false, attrDescr3);
   Descriptor attrDescr4 = new DescriptorSupport();
   attrDescr4.setField("name", "Local2");
   attrDescr4.setField("descriptorType", "attribute");
   ModelMBeanAttributeInfo attrInfo4 =
       new ModelMBeanAttributeInfo(
           "Local2", "java.lang.String", "local attr 2", true, true, false, attrDescr4);
   ModelMBeanAttributeInfo[] attrs =
       new ModelMBeanAttributeInfo[] {attrInfo, attrInfo2, attrInfo3, attrInfo4};
   ModelMBeanOperationInfo operInfo = new ModelMBeanOperationInfo("getArray descr", getArray);
   ModelMBeanOperationInfo operInfo2 = new ModelMBeanOperationInfo("getNumber descr", getNumber);
   ModelMBeanOperationInfo operInfo3 = new ModelMBeanOperationInfo("addOne descr", addOne);
   ModelMBeanOperationInfo operInfo4 = new ModelMBeanOperationInfo("setNumber descr", setNumber);
   ModelMBeanOperationInfo operInfo5 = new ModelMBeanOperationInfo("tweakArray descr", tweakArray);
   ModelMBeanOperationInfo operInfoSetManagedResource =
       new ModelMBeanOperationInfo("setManagedResource descr", setManagedResource);
   ModelMBeanOperationInfo operInfoSendNotification =
       new ModelMBeanOperationInfo("sendNotification descr", sendNotification);
   ModelMBeanOperationInfo operInfoAddAttributeChangeNL =
       new ModelMBeanOperationInfo("AddAttributeChangeNL descr", addAttributeChangeNL);
   ModelMBeanOperationInfo[] opers =
       new ModelMBeanOperationInfo[] {
         operInfo,
         operInfo2,
         operInfo3,
         operInfo4,
         operInfo5,
         operInfoSetManagedResource,
         operInfoSendNotification,
         operInfoAddAttributeChangeNL
       };
   ModelMBeanInfo info =
       new ModelMBeanInfoSupport(
           Resource.class.getName(), "Resourcish resource", attrs, null, opers, null, null);
   mbs.createMBean(
       RequiredModelMBean.class.getName(),
       on,
       new Object[] {info},
       new String[] {ModelMBeanInfo.class.getName()});
   mbs.invoke(
       on,
       "setManagedResource",
       new Object[] {resource, "objectReference"},
       new String[] {"java.lang.Object", "java.lang.String"});
   switch (testno) {
     case 0:
       {
         /* Check  getDescriptors("") on original MBeanInfo */
         final Descriptor[] desc = info.getDescriptors("");
         checkDescriptors(info, desc, "info.getDescriptors(\"\")");
         break;
       }
     case 1:
       {
         /* Check  getDescriptors(null) on original MBeanInfo */
         final Descriptor[] desc = info.getDescriptors(null);
         checkDescriptors(info, desc, "info.getDescriptors(null)");
         break;
       }
     case 2:
       {
         /* Check  getDescriptors("") on retrieved MBeanInfo */
         final MBeanInfo mbi = mbs.getMBeanInfo(on);
         final ModelMBeanInfo model = (ModelMBeanInfo) mbi;
         final Descriptor[] desc = model.getDescriptors("");
         checkDescriptors(info, desc, "model.getDescriptors(\"\")");
         break;
       }
     case 3:
       {
         /* Check  getDescriptors(null) on retrieved MBeanInfo */
         final MBeanInfo mbi = mbs.getMBeanInfo(on);
         final ModelMBeanInfo model = (ModelMBeanInfo) mbi;
         final Descriptor[] desc = model.getDescriptors(null);
         checkDescriptors(info, desc, "model.getDescriptors(null)");
         break;
       }
     default:
       System.err.println("UNKNOWN TEST NUMBER " + testno);
       break;
   }
 }