284 lines
11 KiB
Java
284 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2004, 2015, 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.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @bug 5012634
|
|
* @summary Test that JMX classes use fully-qualified class names
|
|
* in MBeanNotificationInfo
|
|
* @author Eamonn McManus
|
|
* @modules java.management.rmi
|
|
* @run clean NotificationInfoTest
|
|
* @run build NotificationInfoTest
|
|
* @run main NotificationInfoTest
|
|
*/
|
|
|
|
import java.io.*;
|
|
import java.lang.management.*;
|
|
import java.lang.reflect.*;
|
|
import java.net.*;
|
|
import java.nio.file.FileSystem;
|
|
import java.nio.file.FileSystems;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
import javax.management.*;
|
|
import javax.management.relation.*;
|
|
import javax.management.remote.*;
|
|
import javax.management.remote.rmi.*;
|
|
|
|
/*
|
|
* This test finds all classes in the same code-base as the JMX
|
|
* classes that look like Standard MBeans, and checks that if they are
|
|
* NotificationBroadcasters they declare existent notification types.
|
|
* A class looks like a Standard MBean if both Thing and ThingMBean
|
|
* classes exist. So for example javax.management.timer.Timer looks
|
|
* like a Standard MBean because javax.management.timer.TimerMBean
|
|
* exists. Timer is instanceof NotificationBroadcaster, so we expect
|
|
* that ((NotificationBroadcaster) timer).getNotificationInfo() will
|
|
* return an array of MBeanNotificationInfo where each entry has a
|
|
* getName() that names an existent Java class that is a Notification.
|
|
*
|
|
* An MBean is "suspicious" if it is a NotificationBroadcaster but its
|
|
* MBeanNotificationInfo[] is empty. This is legal, but surprising.
|
|
*
|
|
* In order to call getNotificationInfo(), we need an instance of the
|
|
* class. We attempt to make one by calling a public no-arg
|
|
* constructor. But the "construct" method below can be extended to
|
|
* construct specific MBean classes for which the no-arg constructor
|
|
* doesn't exist.
|
|
*
|
|
* The test is obviously not exhaustive, but does catch the cases that
|
|
* failed in 5012634.
|
|
*/
|
|
public class NotificationInfoTest {
|
|
// class or object names where the test failed
|
|
private static final Set<String> failed = new TreeSet<String>();
|
|
|
|
// class or object names where there were no MBeanNotificationInfo entries
|
|
private static final Set<String> suspicious = new TreeSet<String>();
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
System.out.println("Checking that all known MBeans that are " +
|
|
"NotificationBroadcasters have sane " +
|
|
"MBeanInfo.getNotifications()");
|
|
|
|
System.out.println("Checking platform MBeans...");
|
|
checkPlatformMBeans();
|
|
|
|
URL codeBase;
|
|
String home = System.getProperty("java.home");
|
|
Path classFile = Paths.get(home, "modules", "java.management");
|
|
if (Files.isDirectory(classFile)) {
|
|
codeBase = classFile.toUri().toURL();
|
|
} else {
|
|
codeBase = URI.create("jrt:/java.management").toURL();
|
|
}
|
|
|
|
System.out.println();
|
|
System.out.println("Looking for standard MBeans...");
|
|
String[] classes = findStandardMBeans(codeBase);
|
|
|
|
System.out.println("Testing standard MBeans...");
|
|
for (int i = 0; i < classes.length; i++) {
|
|
String name = classes[i];
|
|
Class<?> c;
|
|
try {
|
|
c = Class.forName(name);
|
|
} catch (Throwable e) {
|
|
System.out.println(name + ": cannot load (not public?): " + e);
|
|
continue;
|
|
}
|
|
if (!NotificationBroadcaster.class.isAssignableFrom(c)) {
|
|
System.out.println(name + ": not a NotificationBroadcaster");
|
|
continue;
|
|
}
|
|
if (Modifier.isAbstract(c.getModifiers())) {
|
|
System.out.println(name + ": abstract class");
|
|
continue;
|
|
}
|
|
|
|
NotificationBroadcaster mbean;
|
|
Constructor<?> constr;
|
|
try {
|
|
constr = c.getConstructor();
|
|
} catch (Exception e) {
|
|
System.out.println(name + ": no public no-arg constructor: "
|
|
+ e);
|
|
continue;
|
|
}
|
|
try {
|
|
mbean = (NotificationBroadcaster) constr.newInstance();
|
|
} catch (Exception e) {
|
|
System.out.println(name + ": no-arg constructor failed: " + e);
|
|
continue;
|
|
}
|
|
|
|
check(mbean);
|
|
}
|
|
|
|
System.out.println();
|
|
System.out.println("Testing some explicit cases...");
|
|
|
|
check(new RelationService(false));
|
|
/*
|
|
We can't do this:
|
|
check(new RequiredModelMBean());
|
|
because the Model MBean spec more or less forces us to use the
|
|
names GENERIC and ATTRIBUTE_CHANGE for its standard notifs.
|
|
*/
|
|
checkRMIConnectorServer();
|
|
|
|
System.out.println();
|
|
if (!suspicious.isEmpty())
|
|
System.out.println("SUSPICIOUS CLASSES: " + suspicious);
|
|
|
|
if (failed.isEmpty())
|
|
System.out.println("TEST PASSED");
|
|
else {
|
|
System.out.println("TEST FAILED: " + failed);
|
|
System.exit(1);
|
|
}
|
|
}
|
|
|
|
private static void check(NotificationBroadcaster mbean)
|
|
throws Exception {
|
|
System.out.print(mbean.getClass().getName() + ": ");
|
|
|
|
check(mbean.getClass().getName(), mbean.getNotificationInfo());
|
|
}
|
|
|
|
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());
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void checkRMIConnectorServer() throws Exception {
|
|
JMXServiceURL url = new JMXServiceURL("service:jmx:rmi://");
|
|
RMIConnectorServer connector = new RMIConnectorServer(url, null);
|
|
check(connector);
|
|
}
|
|
|
|
private static void check(String what, MBeanNotificationInfo[] mbnis) {
|
|
System.out.print(what + ": checking notification info: ");
|
|
|
|
if (mbnis.length == 0) {
|
|
System.out.println("NONE (suspicious)");
|
|
suspicious.add(what);
|
|
return;
|
|
}
|
|
|
|
// Each MBeanNotificationInfo.getName() should be an existent
|
|
// Java class that is Notification or a subclass of it
|
|
for (int j = 0; j < mbnis.length; j++) {
|
|
String notifClassName = mbnis[j].getName();
|
|
Class notifClass;
|
|
try {
|
|
notifClass = Class.forName(notifClassName);
|
|
} catch (Exception e) {
|
|
System.out.print("FAILED(" + notifClassName + ": " + e +
|
|
") ");
|
|
failed.add(what);
|
|
continue;
|
|
}
|
|
if (!Notification.class.isAssignableFrom(notifClass)) {
|
|
System.out.print("FAILED(" + notifClassName +
|
|
": not a Notification) ");
|
|
failed.add(what);
|
|
continue;
|
|
}
|
|
System.out.print("OK(" + notifClassName + ") ");
|
|
}
|
|
System.out.println();
|
|
}
|
|
|
|
private static String[] findStandardMBeans(URL codeBase) throws Exception {
|
|
Set<String> names;
|
|
if (codeBase.getProtocol().equalsIgnoreCase("jrt")) {
|
|
names = findStandardMBeansFromRuntime();
|
|
} else {
|
|
names = findStandardMBeansFromDir(codeBase);
|
|
}
|
|
|
|
Set<String> standardMBeanNames = new TreeSet<String>();
|
|
for (String name : names) {
|
|
if (name.endsWith("MBean")) {
|
|
String prefix = name.substring(0, name.length() - 5);
|
|
if (names.contains(prefix))
|
|
standardMBeanNames.add(prefix);
|
|
}
|
|
}
|
|
return standardMBeanNames.toArray(new String[0]);
|
|
}
|
|
|
|
private static Set<String> findStandardMBeansFromRuntime() throws Exception {
|
|
FileSystem fs = FileSystems.getFileSystem(URI.create("jrt:/"));
|
|
Path modules = fs.getPath("/modules");
|
|
return Files.walk(modules)
|
|
.filter(path -> path.toString().endsWith(".class"))
|
|
.map(path -> path.subpath(2, path.getNameCount()))
|
|
.map(Path::toString)
|
|
.map(s -> s.substring(0, s.length() - 6)) // drop .class
|
|
.filter(s -> !s.equals("module-info"))
|
|
.map(s -> s.replace('/', '.'))
|
|
.collect(Collectors.toSet());
|
|
}
|
|
|
|
private static Set<String> findStandardMBeansFromDir(URL codeBase)
|
|
throws Exception {
|
|
File dir = new File(new URI(codeBase.toString()));
|
|
Set<String> names = new TreeSet<String>();
|
|
scanDir(dir, "", names);
|
|
return names;
|
|
}
|
|
|
|
private static void scanDir(File dir, String prefix, Set<String> names)
|
|
throws Exception {
|
|
File[] files = dir.listFiles();
|
|
if (files == null)
|
|
return;
|
|
for (int i = 0; i < files.length; i++) {
|
|
File f = files[i];
|
|
String name = f.getName();
|
|
String p = (prefix.equals("")) ? name : prefix + "." + name;
|
|
if (f.isDirectory())
|
|
scanDir(f, p, names);
|
|
else if (name.endsWith(".class")) {
|
|
p = p.substring(0, p.length() - 6);
|
|
names.add(p);
|
|
}
|
|
}
|
|
}
|
|
}
|