/**
* The start method is called when the WrapperManager is signaled by the native wrapper code that
* it can start its application. This method call is expected to return, so a new thread should be
* launched if necessary.
*
* @param args List of arguments used to initialize the application.
* @return Any error code if the application should exit on completion of the start method. If
* there were no problems then this method should return null.
*/
public Integer start(String[] args) {
if (WrapperManager.isDebugEnabled()) {
System.out.println(Main.getRes().getString("LoadedWrapperListener: start(args)"));
}
Thread mainThread = new Thread(this, "LoadedWrapperListenerMain");
synchronized (this) {
m_startMainArgs = args;
mainThread.start();
// Wait for five seconds to give the application a chance to have failed.
try {
this.wait(5000);
} catch (InterruptedException e) {
}
m_waitTimedOut = true;
if (WrapperManager.isDebugEnabled()) {
System.out.println(
Main.getRes()
.getString(
"LoadedWrapperListener: start(args) end. Main Completed={0}, exitCode={1}",
new Object[] {new Boolean(m_mainComplete), m_mainExitCode}));
}
return m_mainExitCode;
}
}
/** Main method of the actual application. */
private void appMain(String[] args) {
System.out.println(Main.getRes().getString("App Main Starting."));
System.out.println();
// Loop and display 500 long lines of text to place to dump a lot of
// output before the CPU starts being loaded down. This will strain
// the Wrapper just as the CPU suddenly hpegs at 100%.
for (int i = 0; i < 500; i++) {
System.out.println(
new Date()
+ Main.getRes().getString(" Pre {0} of output. ", new Integer(i))
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}
// Start up a thread to thrash the hard disk.
Thread diskThrasher =
new Thread("LoadedWrapperListener_DiskThrasher") {
public void run() {
performDiskThrashing();
}
};
diskThrasher.start();
// Start up a thread to thrash memory.
Thread memoryThrasher =
new Thread("LoadedWrapperListener_MemoryThrasher") {
public void run() {
performMemoryThrashing();
}
};
memoryThrasher.start();
// Start up some threads to eat all available CPU
for (int i = 0; i < 4; i++) {
Thread cpuThrasher =
new Thread("LoadedWrapperListener_CPUThrasher_" + i) {
public void run() {
performCPUThrashing();
}
};
cpuThrasher.start();
}
// Loop and display 5000 long lines of text to place a heavy load on the
// JVM output processing code of the Wrapper while the above threads are
// eating all available CPU.
for (int i = 0; i < 5000; i++) {
System.out.println(
new Date()
+ " Row "
+ i
+ " of output. "
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}
System.out.println();
System.out.println(Main.getRes().getString("App Main Complete."));
}
/**
* Called when the application is shutting down. The Wrapper assumes that this method will return
* fairly quickly. If the shutdown code code could potentially take a long time, then
* WrapperManager.signalStopping() should be called to extend the timeout period. If for some
* reason, the stop method can not return, then it must call WrapperManager.stopped() to avoid
* warning messages from the Wrapper.
*
* @param exitCode The suggested exit code that will be returned to the OS when the JVM exits.
* @return The exit code to actually return to the OS. In most cases, this should just be the
* value of exitCode, however the user code has the option of changing the exit code if there
* are any problems during shutdown.
*/
public int stop(int exitCode) {
if (WrapperManager.isDebugEnabled()) {
System.out.println(
Main.getRes().getString("LoadedWrapperListener: stop({0})", new Integer(exitCode)));
}
return exitCode;
}
/** Runner thread which actually launches the application. */
public void run() {
Throwable t = null;
try {
if (WrapperManager.isDebugEnabled()) {
System.out.println(
Main.getRes().getString("LoadedWrapperListener: invoking start main method"));
}
appMain(m_startMainArgs);
if (WrapperManager.isDebugEnabled()) {
System.out.println(
Main.getRes().getString("LoadedWrapperListener: start main method completed"));
}
synchronized (this) {
// Let the start() method know that the main method returned, in case it is
// still waiting.
m_mainComplete = true;
this.notifyAll();
}
return;
} catch (Throwable e) {
t = e;
}
// If we get here, then an error was thrown. If this happened quickly
// enough, the start method should be allowed to shut things down.
System.out.println(Main.getRes().getString("Encountered an error running start main: {0}", t));
t.printStackTrace();
synchronized (this) {
if (m_waitTimedOut) {
// Shut down here.
WrapperManager.stop(1);
return; // Will not get here.
} else {
// Let start method handle shutdown.
m_mainComplete = true;
m_mainExitCode = new Integer(1);
this.notifyAll();
return;
}
}
}
private void performMemoryThrashing() {
while (!m_mainComplete) {
// 200MB block of memory
byte[][] garbage = new byte[200][];
for (int i = 0; i < garbage.length; i++) {
garbage[i] = new byte[1024 * 1024];
}
garbage = null;
Runtime runtime = Runtime.getRuntime();
long totalMemory = runtime.totalMemory();
long freeMemory = runtime.freeMemory();
System.out.println(
Main.getRes().getString("Total Memory=")
+ totalMemory
+ ", "
+ Main.getRes().getString("Used Memory=")
+ (totalMemory - freeMemory));
}
}
/**
* Called whenever the native wrapper code traps a system control signal against the Java process.
* It is up to the callback to take any actions necessary. Possible values are:
* WrapperManager.WRAPPER_CTRL_C_EVENT, WRAPPER_CTRL_CLOSE_EVENT, WRAPPER_CTRL_LOGOFF_EVENT, or
* WRAPPER_CTRL_SHUTDOWN_EVENT
*
* @param event The system control signal.
*/
public void controlEvent(int event) {
if (WrapperManager.isControlledByNativeWrapper()) {
if (WrapperManager.isDebugEnabled()) {
System.out.println(
Main.getRes()
.getString("LoadedWrapperListener: controlEvent({0}) Ignored", new Integer(event)));
}
// Ignore the event as the native wrapper will handle it.
} else {
if (WrapperManager.isDebugEnabled()) {
System.out.println(
Main.getRes()
.getString(
"LoadedWrapperListener: controlEvent({0}) Stopping", new Integer(event)));
}
// Not being run under a wrapper, so this isn't an NT service and should always exit.
// Handle the event here.
WrapperManager.stop(0);
// Will not get here.
}
}
private void performDiskThrashing() {
while (!m_mainComplete) {
File file = new File("loadedwrapperlistener.dat");
try {
PrintWriter w = new PrintWriter(new FileWriter(file));
try {
for (int i = 0; i < 100; i++) {
w.println(
new Date()
+ Main.getRes().getString(" Row {0} of output. ", new Integer(i))
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");
}
} finally {
w.close();
}
} catch (IOException e) {
e.printStackTrace();
}
file.delete();
}
}
