private int getHttpsPort() {
try {
MBeanServer mBeanServer = MBeanServerFactory.findMBeanServer(null).get(0);
QueryExp query = Query.eq(Query.attr("Scheme"), Query.value("https"));
Set<ObjectName> objectNames = mBeanServer.queryNames(null, query);
if (objectNames != null && objectNames.size() > 0) {
for (ObjectName objectName : objectNames) {
String name = objectName.toString();
if (name.indexOf("port=") > -1) {
String[] parts = name.split("port=");
String port = parts[1];
try {
int portNum = Integer.parseInt(port);
return portNum;
} catch (NumberFormatException e) {
logger.error("Error parsing https port:" + port);
return -1;
}
}
}
}
} catch (Throwable t) {
logger.error("Error getting https port:", t);
}
return -1;
}
/**
* 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 {
Class thisClass = MethodResultTest.class;
Class exoticClass = Exotic.class;
String exoticClassName = Exotic.class.getName();
ClassLoader testClassLoader = thisClass.getClassLoader();
if (!(testClassLoader instanceof URLClassLoader)) {
System.out.println("TEST INVALID: Not loaded by a " + "URLClassLoader: " + testClassLoader);
System.exit(1);
}
URLClassLoader tcl = (URLClassLoader) testClassLoader;
URL[] urls = tcl.getURLs();
ClassLoader shadowLoader =
new ShadowLoader(
urls,
testClassLoader,
new String[] {
exoticClassName, ExoticMBeanInfo.class.getName(), ExoticException.class.getName()
});
Class cl = shadowLoader.loadClass(exoticClassName);
if (cl == exoticClass) {
System.out.println(
"TEST INVALID: Shadow class loader loaded " + "same class as test class loader");
System.exit(1);
}
Thread.currentThread().setContextClassLoader(shadowLoader);
ObjectName on = new ObjectName("a:b=c");
MBeanServer mbs = MBeanServerFactory.newMBeanServer();
mbs.createMBean(Thing.class.getName(), on);
final String[] protos = {"rmi", "iiop", "jmxmp"};
boolean ok = true;
for (int i = 0; i < protos.length; i++) {
try {
ok &= test(protos[i], mbs, on);
System.out.println();
} 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);
}
}
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;
}
}
public void run() {
started = true;
Thread.currentThread().setName("Q2-" + getInstanceId().toString());
try {
/*
* The following code determines whether a MBeanServer exists
* already. If so then the first one in the list is used.
* I have not yet find a way to interrogate the server for
* information other than MBeans so to pick a specific one
* would be difficult.
*/
ArrayList mbeanServerList = MBeanServerFactory.findMBeanServer(null);
if (mbeanServerList.isEmpty()) {
server = MBeanServerFactory.createMBeanServer(JMX_NAME);
} else {
server = (MBeanServer) mbeanServerList.get(0);
}
final ObjectName loaderName = new ObjectName(Q2_CLASS_LOADER);
try {
loader =
(QClassLoader)
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction() {
public Object run() {
return new QClassLoader(server, libDir, loaderName, mainClassLoader);
}
});
server.registerMBean(loader, loaderName);
loader = loader.scan(false);
} catch (Throwable t) {
if (log != null) log.error("initial-scan", t);
else t.printStackTrace();
}
factory = new QFactory(loaderName, this);
initSystemLogger();
addShutdownHook();
q2Thread = Thread.currentThread();
q2Thread.setContextClassLoader(loader);
if (cli != null) cli.start();
initConfigDecorator();
for (int i = 1; !shutdown; i++) {
try {
boolean forceNewClassLoader = scan();
QClassLoader oldClassLoader = loader;
loader = loader.scan(forceNewClassLoader);
if (loader != oldClassLoader) {
oldClassLoader = null; // We want't this to be null so it gets GCed.
System.gc(); // force a GC
log.info(
"new classloader ["
+ Integer.toString(loader.hashCode(), 16)
+ "] has been created");
}
deploy();
checkModified();
relax(SCAN_INTERVAL);
if (i % (3600000 / SCAN_INTERVAL) == 0) logVersion();
} catch (Throwable t) {
log.error("start", t);
relax();
}
}
undeploy();
try {
server.unregisterMBean(loaderName);
} catch (InstanceNotFoundException e) {
log.error(e);
}
if (decorator != null) {
decorator.uninitialize();
}
if (exit && !shuttingDown) System.exit(0);
} catch (Exception e) {
if (log != null) log.error(e);
else e.printStackTrace();
System.exit(1);
}
}