/** ** Main client thread loop */
public void run() {
this.setRunStatus(THREAD_RUNNING);
this.threadStarted();
try {
this.openSocket();
this.inputThread = new InputThread(this.socket, this.readTimeout, this.ioThreadLock);
this.outputThread = new OutputThread(this.socket, this.ioThreadLock);
this.inputThread.start();
this.outputThread.start();
synchronized (this.ioThreadLock) {
while (this.inputThread.isRunning() || this.outputThread.isRunning()) {
try {
this.ioThreadLock.wait();
} catch (Throwable t) {
}
}
}
} catch (NoRouteToHostException nrthe) {
Print.logInfo("Client:ControlThread - Unable to reach " + this.host + ":" + this.port);
nrthe.printStackTrace();
} catch (Throwable t) {
Print.logInfo("Client:ControlThread - " + t);
t.printStackTrace();
} finally {
this.closeSocket();
}
this.setRunStatus(THREAD_STOPPED);
this.threadStopped();
}
public void run() {
StringBuffer data = new StringBuffer();
Print.logDebug("Client:InputThread started");
while (true) {
data.setLength(0);
boolean timeout = false;
try {
if (this.readTimeout > 0L) {
this.socket.setSoTimeout((int) this.readTimeout);
}
ClientSocketThread.socketReadLine(this.socket, -1, data);
} catch (InterruptedIOException ee) { // SocketTimeoutException ee) {
// error("Read interrupted (timeout) ...");
if (getRunStatus() != THREAD_RUNNING) {
break;
}
timeout = true;
// continue;
} catch (Throwable t) {
Print.logError("Client:InputThread - " + t);
t.printStackTrace();
break;
}
if (!timeout || (data.length() > 0)) {
ClientSocketThread.this.handleMessage(data.toString());
}
}
synchronized (this.threadLock) {
this.isRunning = false;
Print.logDebug("Client:InputThread stopped");
this.threadLock.notify();
}
}
private static void usage() {
Print.logInfo("Usage:");
Print.logInfo(" java ... " + ClientSocketThread.class.getName() + " {options}");
Print.logInfo("'Send' Options:");
Print.logInfo(" -host=<host> The destination host");
Print.logInfo(" -port=<port> The destination port");
Print.logInfo(" -send=<data> The data to send (prefix with '0x' for hex data)");
Print.logInfo("'Receive' Options (not yet implemented):");
Print.logInfo(" -port=<port> The port on which to listen for incoming data");
Print.logInfo(" -recv Set to 'receive' mode");
System.exit(1);
}
/** ** ActionListener interface execution ** @param ae The ActionEvent */
public void actionPerformed(ActionEvent ae) {
try {
this.invoke();
} catch (Throwable t) { // trap any method invocation error
Print.logError("'invoke' error " + t);
}
}
/** ** Runs this MethodAction now */
public void run() {
try {
this.invoke();
} catch (Throwable t) { // trap any method invocation error
Print.logError("'invoke' error " + t);
}
}
public void run() {
String command = null;
Print.logInfo("Client:OutputThread started");
while (true) {
/* wait for commands */
synchronized (this.cmdList) {
while ((this.cmdList.size() <= 0) && (getRunStatus() == THREAD_RUNNING)) {
try {
this.cmdList.wait(5000L);
} catch (Throwable t) {
/*ignore*/
}
}
if (getRunStatus() != THREAD_RUNNING) {
break;
}
command = this.cmdList.remove(0).toString();
}
/* send commands */
try {
ClientSocketThread.socketWriteLine(this.socket, command);
} catch (Throwable t) {
Print.logError("Client:OutputThread - " + t);
t.printStackTrace();
break;
}
}
if (getRunStatus() == THREAD_RUNNING) {
Print.logWarn("Client:OutputThread stopped due to error");
} else {
Print.logInfo("Client:OutputThread stopped");
}
synchronized (this.threadLock) {
this.isRunning = false;
Print.logInfo("Client:OutputThread stopped");
this.threadLock.notify();
}
}
/**
* ** Invokes all listeners with an assciated command ** @param r a string that may specify a
* command (possibly one ** of several) associated with the event
*/
protected void invokeListeners(String r) {
if (this.actionListeners != null) {
for (Iterator i = this.actionListeners.iterator(); i.hasNext(); ) {
ActionListener al = (ActionListener) i.next();
ActionEvent ae = new ActionEvent(this, ActionEvent.ACTION_PERFORMED, r);
try {
al.actionPerformed(ae);
} catch (Throwable t) {
Print.logError("Exception: " + t.getMessage());
}
}
}
}
/** ** Main entry point for testing/debugging ** @param argv Comand-line arguments */
public static void main(String argv[]) {
RTConfig.setCommandLineArgs(argv);
String host = RTConfig.getString(ARG_HOST, null);
int port = RTConfig.getInt(ARG_PORT, 0);
/* send data */
if (RTConfig.hasProperty(ARG_SEND)) {
if (StringTools.isBlank(host)) {
Print.logError("Target host not specified");
usage();
}
if (port <= 0) {
Print.logError("Target port not specified");
usage();
}
String dataStr = RTConfig.getString(ARG_SEND, "hello");
byte data[] =
dataStr.startsWith("0x") ? StringTools.parseHex(dataStr, null) : dataStr.getBytes();
ClientSocketThread cst = new ClientSocketThread(host, port);
try {
cst.openSocket();
cst.socketWriteBytes(data);
} catch (Throwable t) {
Print.logException("Error", t);
} finally {
cst.closeSocket();
}
System.exit(0);
}
/* receive data */
if (RTConfig.hasProperty(ARG_RECEIVE)) {
if (port <= 0) {
Print.logError("Target port not specified");
usage();
}
if (!StringTools.isBlank(host)) {
Print.logWarn("Specified 'host' will be ignored");
}
Print.logError("Receive not yet implemented ...");
System.exit(99);
}
/* show usage */
usage();
}
/** ** Called when the thread has stopped */
protected void threadStopped() {
Print.logDebug("Client:ControlThread stopped ...");
}
