/**
* Define an operation. Explicit definition of an operation. Reflection is used to locate method
* called.
*
* @param opInfo
*/
public synchronized void defineOperation(ModelMBeanOperationInfo opInfo) {
_dirty = true;
Class oClass = _object.getClass();
try {
MBeanParameterInfo[] pInfo = opInfo.getSignature();
Class[] types = new Class[pInfo.length];
String method = opInfo.getName() + "(";
for (int i = 0; i < pInfo.length; i++) {
Class type = TypeUtil.fromName(pInfo[i].getType());
if (type == null)
type = Thread.currentThread().getContextClassLoader().loadClass(pInfo[i].getType());
types[i] = type;
method += (i > 0 ? "," : "") + pInfo[i].getType();
}
method += ")";
_method.put(method, oClass.getMethod(opInfo.getName(), types));
_operations.add(opInfo);
} catch (Exception e) {
log.warn(LogSupport.EXCEPTION, e);
throw new IllegalArgumentException(e.toString());
}
}
/**
* Define an attribute. Explicit definition of an attribute. Reflection is used to locate the
* actual getter and setter methods.
*
* @param attrInfo ModelMBeanAttributeInfo.
*/
public synchronized void defineAttribute(ModelMBeanAttributeInfo attrInfo) {
if (_object == null) throw new IllegalStateException("No Object");
_dirty = true;
String name = attrInfo.getName();
String uName = name.substring(0, 1).toUpperCase() + name.substring(1);
Class oClass = _object.getClass();
try {
Class type = TypeUtil.fromName(attrInfo.getType());
if (type == null)
type = Thread.currentThread().getContextClassLoader().loadClass(attrInfo.getType());
Method getter = null;
Method setter = null;
if (attrInfo.isReadable())
getter =
oClass.getMethod((attrInfo.isIs() ? "is" : "get") + uName, (java.lang.Class[]) null);
if (attrInfo.isWritable()) setter = oClass.getMethod("set" + uName, new Class[] {type});
_getter.put(name, getter);
_setter.put(name, setter);
_attributes.add(attrInfo);
} catch (Exception e) {
log.warn(LogSupport.EXCEPTION, e);
throw new IllegalArgumentException(e.toString());
}
}
private static void checkThreadInfo() throws Exception {
// assume all threads stay alive
long[] ids = (long[]) server.getAttribute(thread, "AllThreadIds");
Object result = server.invoke(thread, "getThreadInfo", new Object[] {ids}, new String[] {"[J"});
for (CompositeData cd : (CompositeData[]) result) {
printThreadInfo(cd);
}
result =
server.invoke(
thread,
"getThreadInfo",
new Object[] {ids, new Integer(2)},
new String[] {"[J", "int"});
for (CompositeData cd : (CompositeData[]) result) {
printThreadInfo(cd);
}
long id = Thread.currentThread().getId();
result =
server.invoke(thread, "getThreadInfo", new Object[] {new Long(id)}, new String[] {"long"});
printThreadInfo((CompositeData) result);
result =
server.invoke(
thread,
"getThreadInfo",
new Object[] {new Long(id), new Integer(2)},
new String[] {"long", "int"});
printThreadInfo((CompositeData) result);
}
/**
* Builds a new AgentMBeanServerConnectionFactory and returns the underlying
* MBeanServerConnection
*
* @return a new MBeanServerConnection
*/
public MBeanServerConnection build() {
final String key = buildKey();
MBeanServerConnection conn = INSTANCES.get(key);
if (conn == null) {
synchronized (INSTANCES) {
conn = INSTANCES.get(key);
if (conn == null) {
conn =
(MBeanServerConnection)
Proxy.newProxyInstance(
Thread.currentThread().getContextClassLoader(),
new Class[] {MBeanServerConnection.class},
new AgentMBeanServerConnectionFactory(this));
INSTANCES.put(key, conn);
channel
.getCloseFuture()
.addListener(
new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
INSTANCES.remove(key);
}
});
}
}
}
return conn;
}
// Acquire the lock if state is zero
public boolean tryAcquire(int acquires) {
assert acquires == 1; // Otherwise unused
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
protected int pick(int iThink, boolean couldCreate) {
final int id = Thread.currentThread().hashCode();
final int s = _availSafe.size();
for (int i = 0; i < s; i++) {
DBPort p = _availSafe.get(i);
if (p._lastThread == id) return i;
}
if (couldCreate) return -1;
return iThink;
}
public Q2(String[] args) {
super();
this.args = args;
startTime = System.currentTimeMillis();
instanceId = UUID.randomUUID();
parseCmdLine(args);
libDir = new File(deployDir, "lib");
dirMap = new TreeMap();
deployDir.mkdirs();
mainClassLoader = Thread.currentThread().getContextClassLoader();
}
/**
* Define an operation on the managed object. Defines an operation with parameters. Refection is
* used to determine find the method and it's return type. The description of the method is found
* with a call to findDescription on "name(signature)". The name and description of each parameter
* is found with a call to findDescription with "name(partialSignature", the returned description
* is for the last parameter of the partial signature and is assumed to start with the parameter
* name, followed by a colon.
*
* @param name The name of the method call.
* @param signature The types of the operation parameters.
* @param impact Impact as defined in MBeanOperationInfo
* @param onMBean true if the operation is defined on the mbean
*/
public synchronized void defineOperation(
String name, String[] signature, int impact, boolean onMBean) {
_dirty = true;
Class oClass = onMBean ? this.getClass() : _object.getClass();
if (signature == null) signature = new String[0];
try {
Class[] types = new Class[signature.length];
MBeanParameterInfo[] pInfo = new MBeanParameterInfo[signature.length];
// Check types and build methodKey
String methodKey = name + "(";
for (int i = 0; i < signature.length; i++) {
Class type = TypeUtil.fromName(signature[i]);
if (type == null)
type = Thread.currentThread().getContextClassLoader().loadClass(signature[i]);
types[i] = type;
signature[i] = type.isPrimitive() ? TypeUtil.toName(type) : signature[i];
methodKey += (i > 0 ? "," : "") + signature[i];
}
methodKey += ")";
// Build param infos
for (int i = 0; i < signature.length; i++) {
String description = findDescription(methodKey + "[" + i + "]");
int colon = description.indexOf(":");
if (colon < 0) {
description = "param" + i + ":" + description;
colon = description.indexOf(":");
}
pInfo[i] =
new MBeanParameterInfo(
description.substring(0, colon).trim(),
signature[i],
description.substring(colon + 1).trim());
}
// build the operation info
Method method = oClass.getMethod(name, types);
Class returnClass = method.getReturnType();
_method.put(methodKey, method);
_operations.add(
new ModelMBeanOperationInfo(
name,
findDescription(methodKey),
pInfo,
returnClass.isPrimitive() ? TypeUtil.toName(returnClass) : (returnClass.getName()),
impact));
} catch (Exception e) {
log.warn("operation " + name, e);
throw new IllegalArgumentException(e.toString());
}
}
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 DBPort get() {
DBPort port = null;
if (!_waitingSem.tryAcquire()) throw new SemaphoresOut();
try {
port = get(_options.maxWaitTime);
} finally {
_waitingSem.release();
}
if (port == null) throw new ConnectionWaitTimeOut(_options.maxWaitTime);
port._lastThread = Thread.currentThread().hashCode();
return port;
}
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);
}
}
// The Run Method.
// Started by main() on a single thread, this code publishes Cloud membership
// to the Cloud once a second (across all members). If anybody disagrees
// with the membership Heartbeat, they will start a round of Paxos group
// discovery.
public void run() {
MBeanServer mbs = ManagementFactory.getPlatformMBeanServer();
ObjectName os;
try {
os = new ObjectName("java.lang:type=OperatingSystem");
} catch (MalformedObjectNameException e) {
throw Log.errRTExcept(e);
}
Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
int counter = 0;
while (true) {
// Once per second, for the entire cloud a Node will multi-cast publish
// itself, so other unrelated Clouds discover each other and form up.
try {
Thread.sleep(SLEEP);
} // Only once-sec per entire Cloud
catch (InterruptedException e) {
}
// Update the interesting health self-info for publication also
H2O cloud = H2O.CLOUD;
HeartBeat hb = H2O.SELF._heartbeat;
hb._hb_version = HB_VERSION++;
hb._jvm_boot_msec = TimeLine.JVM_BOOT_MSEC;
final Runtime run = Runtime.getRuntime();
hb.set_free_mem(run.freeMemory());
hb.set_max_mem(run.maxMemory());
hb.set_tot_mem(run.totalMemory());
hb._keys = (H2O.STORE.size());
hb.set_valsz(myHisto.histo(false)._cached);
hb._num_cpus = (char) run.availableProcessors();
if (counter % 300 == 2) {
// run mini-benchmark every 5 mins
hb._gflops = Linpack.run();
hb._membw = MemoryBandwidth.run();
}
Object load = null;
try {
load = mbs.getAttribute(os, "SystemLoadAverage");
} catch (Exception e) {
// Ignore, data probably not available on this VM
}
hb._system_load_average = load instanceof Double ? ((Double) load).floatValue() : 0;
int rpcs = 0;
for (H2ONode h2o : cloud._memary) rpcs += h2o.taskSize();
hb._rpcs = (char) rpcs;
// Scrape F/J pool counts
hb._fjthrds = new short[H2O.MAX_PRIORITY + 1];
hb._fjqueue = new short[H2O.MAX_PRIORITY + 1];
for (int i = 0; i < hb._fjthrds.length; i++) {
hb._fjthrds[i] = (short) H2O.getWrkThrPoolSize(i);
hb._fjqueue[i] = (short) H2O.getWrkQueueSize(i);
}
hb._tcps_active = (char) H2ONode.TCPS.get();
// get the usable and total disk storage for the partition where the
// persistent KV pairs are stored
hb.set_free_disk(Persist.getIce().getUsableSpace());
hb.set_max_disk(Persist.getIce().getTotalSpace());
// get cpu utilization for the system and for this process. (linux only.)
LinuxProcFileReader lpfr = new LinuxProcFileReader();
lpfr.read();
if (lpfr.valid()) {
hb._system_idle_ticks = lpfr.getSystemIdleTicks();
hb._system_total_ticks = lpfr.getSystemTotalTicks();
hb._process_total_ticks = lpfr.getProcessTotalTicks();
hb._process_num_open_fds = lpfr.getProcessNumOpenFds();
} else {
hb._system_idle_ticks = -1;
hb._system_total_ticks = -1;
hb._process_total_ticks = -1;
hb._process_num_open_fds = -1;
}
hb._pid = lpfr.getProcessID();
// Announce what Cloud we think we are in.
// Publish our health as well.
UDPHeartbeat.build_and_multicast(cloud, hb);
// If we have no internet connection, then the multicast goes
// nowhere and we never receive a heartbeat from ourselves!
// Fake it now.
long now = System.currentTimeMillis();
H2O.SELF._last_heard_from = now;
// Look for napping Nodes & propose removing from Cloud
for (H2ONode h2o : cloud._memary) {
long delta = now - h2o._last_heard_from;
if (delta > SUSPECT) { // We suspect this Node has taken a dirt nap
if (!h2o._announcedLostContact) {
Paxos.print("hart: announce suspect node", cloud._memary, h2o.toString());
h2o._announcedLostContact = true;
}
} else if (h2o._announcedLostContact) {
Paxos.print("hart: regained contact with node", cloud._memary, h2o.toString());
h2o._announcedLostContact = false;
}
}
counter++;
}
}