6b53043eea
6299231: Add support for named MBean Servers New javax.management.namespace package. Reviewed-by: emcmanus
441 lines
17 KiB
Java
441 lines
17 KiB
Java
/*
|
|
* Copyright 2003 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
|
|
* @summary Test named MBeanServers.
|
|
* @author Daniel Fuchs
|
|
* @run clean NamedMBeanServerTest
|
|
* @run build NamedMBeanServerTest
|
|
* @run main NamedMBeanServerTest
|
|
*/
|
|
|
|
import java.util.Arrays;
|
|
import java.util.EnumSet;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import javax.management.MBeanServer;
|
|
import javax.management.MBeanServerBuilder;
|
|
import javax.management.MBeanServerDelegate;
|
|
import javax.management.MBeanServerFactory;
|
|
|
|
/**
|
|
* This test can probably be leveraged in the JCK to test compatibilty
|
|
* of MBeanServerFactory *Name* method implementation.
|
|
* @author dfuchs
|
|
*/
|
|
public class NamedMBeanServerTest {
|
|
|
|
/**
|
|
* One enum value for each way of creating an MBeanServer through the
|
|
* MBeanServerFactory
|
|
*/
|
|
public static enum Creator {
|
|
newMBeanServer() {
|
|
public MBeanServer create(String domain) {
|
|
return MBeanServerFactory.newMBeanServer(domain);
|
|
}
|
|
public String test(MBeanServer server, String domain) {
|
|
System.out.println(toString()+"("+domain+")");
|
|
return test(server,
|
|
MBeanServerFactory.DEFAULT_MBEANSERVER_NAME,
|
|
domain);
|
|
}
|
|
public MBeanServer[] servers(Config config) {
|
|
return config.ndServers;
|
|
}
|
|
public String[] strings(Config config) {
|
|
return domains(config);
|
|
}
|
|
public String[] domains(Config config) {
|
|
return config.newDomains;
|
|
}
|
|
public String[] names(Config config) {
|
|
return null;
|
|
}
|
|
},
|
|
createMBeanServer() {
|
|
public MBeanServer create(String domain) {
|
|
return MBeanServerFactory.createMBeanServer(domain);
|
|
}
|
|
public String test(MBeanServer server, String domain) {
|
|
System.out.println(toString()+"("+domain+")");
|
|
return test(server,MBeanServerFactory.DEFAULT_MBEANSERVER_NAME,
|
|
domain);
|
|
}
|
|
public MBeanServer[] servers(Config config) {
|
|
return config.cdServers;
|
|
}
|
|
public String[] strings(Config config) {
|
|
return domains(config);
|
|
}
|
|
public String[] domains(Config config) {
|
|
return config.createDomains;
|
|
}
|
|
public String[] names(Config config) {
|
|
return null;
|
|
}
|
|
},
|
|
newNamedMBeanServer() {
|
|
public MBeanServer create(String name) {
|
|
return MBeanServerFactory.newNamedMBeanServer(name,null);
|
|
}
|
|
public String test(MBeanServer server, String name) {
|
|
System.out.println(toString()+"("+name+",null)");
|
|
return test(server,name,"DefaultDomain");
|
|
}
|
|
public MBeanServer[] servers(Config config) {
|
|
return config.nnServers;
|
|
}
|
|
public String[] strings(Config config) {
|
|
return names(config);
|
|
}
|
|
public String[] domains(Config config) {
|
|
return null;
|
|
}
|
|
public String[] names(Config config) {
|
|
return config.newNames;
|
|
}
|
|
},
|
|
createNamedMBeanServer() {
|
|
public MBeanServer create(String name) {
|
|
return MBeanServerFactory.createNamedMBeanServer(name,null);
|
|
}
|
|
public String test(MBeanServer server, String name) {
|
|
System.out.println(toString()+"("+name+",null)");
|
|
return test(server,name,"DefaultDomain");
|
|
}
|
|
public MBeanServer[] servers(Config config) {
|
|
return config.cnServers;
|
|
}
|
|
public String[] strings(Config config) {
|
|
return names(config);
|
|
}
|
|
public String[] domains(Config config) {
|
|
return null;
|
|
}
|
|
public String[] names(Config config) {
|
|
return config.createNames;
|
|
}
|
|
};
|
|
|
|
// creates an MBeanServer using the specified input string.
|
|
// either a domain, (for UNNAMED) or a mbeanServerName (for NAMED)
|
|
public abstract MBeanServer create(String string);
|
|
|
|
// test the created server against the string used as input to create
|
|
// it.
|
|
public abstract String test(MBeanServer server, String ref);
|
|
|
|
public abstract MBeanServer[] servers(Config config);
|
|
public abstract String[] strings(Config config);
|
|
public abstract String[] names(Config config);
|
|
public abstract String[] domains(Config config);
|
|
|
|
public MBeanServer[] servers(Config config, String... refs) {
|
|
final MBeanServer[] servers = servers(config);
|
|
final String[] strings = strings(config);
|
|
final MBeanServer[] res = new MBeanServer[refs.length];
|
|
for (int i=0;i<refs.length;i++) {
|
|
for (int j=0;j<strings.length;j++) {
|
|
if (strings[j].equals(refs[i]))
|
|
res[i]=servers[j];
|
|
}
|
|
if (res[i] == null)
|
|
throw new IllegalArgumentException(refs[i]);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
String test(MBeanServer server, String name, String domain) {
|
|
// whether the MBeanServer was created throug a "create" method
|
|
boolean registered = REFERENCED.contains(this);
|
|
if (!server.getDefaultDomain().equals(domain)) {
|
|
return "Unexpected default domain: " +
|
|
server.getDefaultDomain() + ", should be: " + domain;
|
|
}
|
|
if (!MBeanServerFactory.getMBeanServerName(server).
|
|
equals(name)) {
|
|
return " Unexpected name: " +
|
|
MBeanServerFactory.getMBeanServerName(server) +
|
|
", should be: " + name;
|
|
}
|
|
List<MBeanServer> found =
|
|
MBeanServerFactory.findMBeanServerByName(name);
|
|
if (!registered && found.contains(server))
|
|
return " Server "+name+" found by name - " +
|
|
"but should not be registered";
|
|
if (!registered &&
|
|
!name.equals(MBeanServerFactory.DEFAULT_MBEANSERVER_NAME) &&
|
|
found.size()>0)
|
|
return " Server "+name+" had too many matches: " + found.size();
|
|
if (registered && !found.contains(server))
|
|
return " Server "+name+" not found by name - " +
|
|
"but is registered!";
|
|
if (registered &&
|
|
!name.equals(MBeanServerFactory.DEFAULT_MBEANSERVER_NAME) &&
|
|
!(found.size()==1))
|
|
return " Server "+name+" had too many matches: " + found.size();
|
|
return null;
|
|
}
|
|
|
|
public static final EnumSet<Creator> NAMED =
|
|
EnumSet.of(createNamedMBeanServer, newNamedMBeanServer);
|
|
public static final EnumSet<Creator> UNNAMED =
|
|
EnumSet.complementOf(NAMED);
|
|
public static final EnumSet<Creator> REFERENCED =
|
|
EnumSet.of(createMBeanServer, createNamedMBeanServer);
|
|
public static final EnumSet<Creator> UNREFERENCED =
|
|
EnumSet.complementOf(REFERENCED);
|
|
|
|
}
|
|
|
|
public static class Config {
|
|
final String[] newDomains;
|
|
final String[] createDomains;
|
|
final String[] newNames;
|
|
final String[] createNames;
|
|
final MBeanServer[] ndServers;
|
|
final MBeanServer[] cdServers;
|
|
final MBeanServer[] nnServers;
|
|
final MBeanServer[] cnServers;
|
|
final Map<String,Set<MBeanServer>> queries;
|
|
Config(String[][] data) {
|
|
this(data[0],data[1],data[2],data[3]);
|
|
}
|
|
Config(String[] nd, String[] cd, String[] nn, String[] cn) {
|
|
this.newDomains=nd.clone();
|
|
this.createDomains=cd.clone();
|
|
this.newNames=nn.clone();
|
|
this.createNames=cn.clone();
|
|
ndServers = new MBeanServer[nd.length];
|
|
cdServers = new MBeanServer[cd.length];
|
|
nnServers = new MBeanServer[nn.length];
|
|
cnServers = new MBeanServer[cn.length];
|
|
queries = new HashMap<String,Set<MBeanServer>>();
|
|
init();
|
|
}
|
|
private void init() {
|
|
for (Creator c : Creator.values()) fill(c);
|
|
addQuery(null,Creator.createMBeanServer.servers(this));
|
|
addQuery(null,Creator.createNamedMBeanServer.servers(this));
|
|
addQuery("?*",Creator.createMBeanServer.servers(this));
|
|
addQuery("?*",Creator.createNamedMBeanServer.servers(this));
|
|
addQuery("*",Creator.createMBeanServer.servers(this));
|
|
addQuery("*",Creator.createNamedMBeanServer.servers(this));
|
|
addQuery(MBeanServerFactory.DEFAULT_MBEANSERVER_NAME,
|
|
Creator.createMBeanServer.servers(this));
|
|
}
|
|
private void addQuery(String pattern, MBeanServer... servers) {
|
|
final Set<MBeanServer> s = getQuery(pattern);
|
|
s.addAll(Arrays.asList(servers));
|
|
}
|
|
public Set<MBeanServer> getQuery(String pattern) {
|
|
final Set<MBeanServer> s = queries.get(pattern);
|
|
if (s != null) return s;
|
|
queries.put(pattern,new HashSet<MBeanServer>());
|
|
return queries.get(pattern);
|
|
}
|
|
public Set<String> getPatterns() {
|
|
return queries.keySet();
|
|
}
|
|
private void fill(Creator creator) {
|
|
fill(creator.servers(this),creator.strings(this),creator);
|
|
}
|
|
private void fill(MBeanServer[] dest, String[] src, Creator creator) {
|
|
for(int i=0;i<src.length;i++) dest[i]=creator.create(src[i]);
|
|
}
|
|
|
|
}
|
|
|
|
static String[] domains(String... str) {
|
|
return str;
|
|
}
|
|
static String[] names(String... str) {
|
|
return str;
|
|
}
|
|
final static Config test1 = new Config(domains("foo1","foo2","foo3"),
|
|
domains("foobar1","foobar2","foobar3","foobar4"),
|
|
names("bar1","bar2"),
|
|
names("barfoo1","barfoo2","barfoo3","batfox1","catfog2","foofoo3"));
|
|
static {
|
|
test1.addQuery("b*",Creator.createNamedMBeanServer.servers(test1,
|
|
"barfoo1","barfoo2","barfoo3","batfox1"));
|
|
test1.addQuery("*arf*",Creator.createNamedMBeanServer.servers(test1,
|
|
"barfoo1","barfoo2","barfoo3"));
|
|
test1.addQuery("*a?f*",Creator.createNamedMBeanServer.servers(test1,
|
|
"barfoo1","barfoo2","barfoo3","batfox1","catfog2"));
|
|
test1.addQuery("",new MBeanServer[0]);
|
|
test1.addQuery("-",new MBeanServer[0]);
|
|
test1.addQuery("def*",Creator.createMBeanServer.servers(test1));
|
|
}
|
|
|
|
public static void test(Config config) throws Exception {
|
|
for (Creator c : Creator.values()) {
|
|
final MBeanServer[] s = c.servers(config);
|
|
final String[] ref = c.strings(config);
|
|
for (int i=0;i<s.length;i++) {
|
|
final String msg = c.test(s[i], ref[i]);
|
|
if (msg != null)
|
|
throw new Exception(String.valueOf(c)+"["+i+"]: "+msg);
|
|
}
|
|
}
|
|
for (String pat : config.getPatterns()) {
|
|
System.out.print("findMBeanServerByName(\""+pat+"\"): [");
|
|
final List<MBeanServer> found =
|
|
MBeanServerFactory.findMBeanServerByName(pat);
|
|
String sep=" ";
|
|
for (MBeanServer m : found) {
|
|
System.out.print(sep+MBeanServerFactory.getMBeanServerName(m));
|
|
sep=", ";
|
|
}
|
|
System.out.println(" ]");
|
|
final Set<MBeanServer> founds = new HashSet<MBeanServer>();
|
|
founds.addAll(found);
|
|
if (!founds.equals(config.getQuery(pat))) {
|
|
final String msg =
|
|
"bad result for findMBeanServerByName(\""+
|
|
pat+"\"): expected "+config.getQuery(pat).size()+", "+
|
|
"got "+founds.size();
|
|
throw new Exception(msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void testexception(Creator c, String name,
|
|
Class<? extends Exception> error) throws Exception {
|
|
Exception failed = null;
|
|
MBeanServer server = null;
|
|
try {
|
|
server = c.create(name);
|
|
} catch (Exception x) {
|
|
failed = x;
|
|
} finally {
|
|
if (Creator.REFERENCED.contains(c) && server!=null) {
|
|
MBeanServerFactory.releaseMBeanServer(server);
|
|
}
|
|
}
|
|
if (failed == null && error != null) {
|
|
throw new Exception("Expected "+error.getName()+
|
|
" for "+c+"("+name+")");
|
|
}
|
|
if (error != null && !error.isInstance(failed))
|
|
throw new Exception("Expected "+error.getName()+
|
|
" for "+c+"("+name+"), caught "+failed);
|
|
System.out.println(""+c+"("+name+") PASSED: "+
|
|
(failed==null?"no exception":String.valueOf(failed)));
|
|
}
|
|
|
|
private static final Map<String,Class<? extends Exception>> failures =
|
|
new LinkedHashMap<String,Class<? extends Exception>>();
|
|
private static final Map<String,Class<? extends Exception>> legacy =
|
|
new LinkedHashMap<String,Class<? extends Exception>>();
|
|
private static final String[] illegalnames = {
|
|
"", "-", ":", ";", "?", "*", "wom?bat", "ran:tan.plan",
|
|
"rin;tin.tin", "tab*mow"
|
|
|
|
};
|
|
private static final String[] legalnames = {
|
|
"wombat", "top.tip", "ran.tan.plan", "rin.tin.tin!"
|
|
};
|
|
private static final String[] nofailures = {
|
|
MBeanServerFactory.DEFAULT_MBEANSERVER_NAME, "default", null
|
|
};
|
|
static {
|
|
for (String s:illegalnames)
|
|
failures.put(s, IllegalArgumentException.class);
|
|
for (String s:nofailures)
|
|
failures.put(s, null);
|
|
legacy.putAll(failures);
|
|
for (String s:legalnames)
|
|
legacy.put(s, UnsupportedOperationException.class);
|
|
|
|
}
|
|
|
|
public static void test2(Map<String,Class<? extends Exception>> config)
|
|
throws Exception {
|
|
for (Creator c:Creator.NAMED) {
|
|
for (String s:config.keySet()) testexception(c, s, config.get(s));
|
|
}
|
|
}
|
|
|
|
public static class LegacyBuilder extends MBeanServerBuilder {
|
|
|
|
@Override
|
|
public MBeanServerDelegate newMBeanServerDelegate() {
|
|
return new MBeanServerDelegate() {
|
|
@Override
|
|
public synchronized String getMBeanServerId() {
|
|
return "gloups";
|
|
}
|
|
};
|
|
}
|
|
|
|
}
|
|
public static class LegacyBuilder2 extends MBeanServerBuilder {
|
|
|
|
@Override
|
|
public MBeanServerDelegate newMBeanServerDelegate() {
|
|
return new MBeanServerDelegate() {
|
|
@Override
|
|
public synchronized String getMBeanServerId() {
|
|
return "c'est la vie...";
|
|
}
|
|
@Override
|
|
public synchronized void setMBeanServerName(String name) {
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
public static void test3(Map<String,Class<? extends Exception>> config,
|
|
String builderClassName)
|
|
throws Exception {
|
|
final String builder =
|
|
System.getProperty("javax.management.builder.initial");
|
|
System.setProperty("javax.management.builder.initial",
|
|
builderClassName);
|
|
try {
|
|
test2(config);
|
|
} finally {
|
|
if (builder != null)
|
|
System.setProperty("javax.management.builder.initial", builder);
|
|
else
|
|
System.clearProperty("javax.management.builder.initial");
|
|
}
|
|
}
|
|
|
|
public static void main(String[] args) throws Exception {
|
|
test(test1);
|
|
test2(failures);
|
|
test3(legacy,LegacyBuilder.class.getName());
|
|
test3(legacy,LegacyBuilder2.class.getName());
|
|
}
|
|
}
|