public void handle(IPC.MSG_INSTANCE msgInstance, Object callData) {
System.out.println(
"msg1Handler: Receiving message "
+ IPC.msgInstanceName(msgInstance)
+ " of "
+ IPC.dataLength(msgInstance)
+ " bytes");
System.out.println(" Java data: " + callData + " [" + clientData + "]");
}
public void handle(IPC.MSG_INSTANCE msgInstance, Object callData) {
System.out.println(
"query2Handler: Receiving message "
+ IPC.msgInstanceName(msgInstance)
+ " ("
+ callData
+ ")");
float[][] matrix = ((matrix_list) callData).matrix;
for (int i = 0; i < 2; i++) for (int j = 0; j < 2; j++) matrix[i][j]++;
System.out.println("IPC.respondData(" + RESPONSE2_MSG + ", " + matrixString(matrix) + ")");
IPC.respondData(msgInstance, RESPONSE2_MSG, matrix);
}
public void handle(IPC.MSG_INSTANCE msgInstance, Object callData) {
String publishStr = "Published";
String responseStr = "Responded";
System.out.println(
"queryHandler: Receiving message "
+ IPC.msgInstanceName(msgInstance)
+ " of "
+ IPC.dataLength(msgInstance)
+ " bytes");
System.out.println(" Java data: " + callData);
// Publish this message -- all subscribers get it
System.out.println("\n IPC.publishData(" + MSG2 + ", '" + publishStr + "')");
IPC.publishData(MSG2, publishStr);
// Respond with this message -- only the query handler gets it
IPC.respondData(msgInstance, MSG2, responseStr);
}
public void handle(int fd) {
try {
int in = System.in.read();
System.out.println("[" + clientData + "] Received: " + (char) in);
if (in == 'q') {
IPC.disconnect();
System.exit(-1);
} else if (in == 'm') {
IPC.publishData(MSG2, "Forwarding");
} else if (in == 'u') {
IPC.unsubscribeFD(fd);
}
// Read in any extra bytes
while (System.in.available() > 0) System.in.read();
} catch (Exception e) {
e.printStackTrace();
}
}
public void handle(IPC.MSG_INSTANCE msgInstance, Object callData) {
System.out.println(
"replyHandler: Receiving message "
+ IPC.msgInstanceName(msgInstance)
+ " ("
+ callData
+ ") ["
+ clientData
+ "]");
}
/**
* ************************************************************** TESTS OF THE BASIC IPC INTERFACE
* **************************************************************
*/
public static void main(String args[]) throws Exception {
// Connect to the central server
System.out.println("\nIPC.connect(" + TASK_NAME + ")");
IPC.connect(TASK_NAME);
// Just for kicks -- make sure it works
IPC.setContext(IPC.getContext());
// Default is to exit on error; Override default, because some of the
// tests in this file explicitly induce errors.
System.out.println("\nIPC.setVerbosity(IPC.Print_Errors)");
IPC.setVerbosity(IPC.IPC_Print_Errors);
/* Test out the timers */
long now = IPC.timeInMillis();
System.out.println(
"\nIPC_addTimer(1000, TRIGGER_FOREVER, " + " new timerHandler(\"timer1\", " + now + "))");
IPC.addTimer(1000, IPC.TRIGGER_FOREVER, new timerHandler("timer1", now));
// Does not make sense to define a fixed-length Java message
// Define a variable length message (simple format string)
System.out.println("\nIPC.defineMsg(" + MSG1 + ", " + STRING_FORMAT + ")");
IPC.defineMsg(MSG1, STRING_FORMAT);
// Define a variable length message (simple format string)
System.out.println("\nIPC.defineMsg(" + MSG2 + ", " + STRING_FORMAT + ")");
IPC.defineMsg(MSG2, STRING_FORMAT);
System.out.println("\nIPC.isMsgDefined(" + MSG1 + ") => " + IPC.isMsgDefined(MSG1));
System.out.println("\nIPC.isMsgDefined(" + MSG3 + ") => " + IPC.isMsgDefined(MSG3));
// Subscribe to the first message, with client data
System.out.println("\nIPC.subscribeData(" + MSG1 + ", new msg1Handler(client1a))");
msg1Handler msgHandler1 = new msg1Handler("client1a");
IPC.subscribeData(MSG1, msgHandler1, String.class);
// Subscribe to the second message, with client data
System.out.println("\nIPC.subscribeData(" + MSG2 + ", new msg1Handler(client2a))");
IPC.subscribeData(MSG2, new msg1Handler("client2a"), String.class);
// Publish the first message and listen for it (in this simple
// example program, both publisher and subscriber are in the same process
String msgData = "abcde";
System.out.println("\nIPC.publishData(" + MSG1 + ", " + msgData + ")");
if (IPC.publishData(MSG1, msgData) == IPC.IPC_OK) IPC.listenClear(1000);
msgData = "abcde";
System.out.println("\nIPC.publishData(" + MSG2 + ", " + msgData + ")");
if (IPC.publishData(MSG2, msgData) == IPC.IPC_OK) IPC.listenClear(1000);
// Get notified when handlers subscribe/unsubscribe to "msg2"
System.out.println("\n" + IPC.numHandlers(MSG2) + " handlers currently subscribed to " + MSG2);
System.out.println("\nIPC.subscribeHandlerChange(" + MSG2 + ", new handlerChangeHandler())");
IPC.subscribeHandlerChange(MSG2, new handlerChangeHandler());
// Subscribe a second message handler for "msg2"
System.out.println("\nIPC.subscribeData(" + MSG2 + ", new msg2Handler(client2b))");
IPC.subscribeData(MSG2, new msg2Handler("client2b"), String.class);
// If doing direct broadcasts, need to listen to get the direct info update
IPC.listen(250);
// Publish the message -- receive two messages (one for msg1Handler, one
// for msg2Handler).
msgData = "abcdefg";
System.out.println("\nIPC.publishData(" + MSG2 + ", " + msgData + ")");
if (IPC.publishData(MSG2, msgData) == IPC.IPC_OK) {
// Make sure all the subscribers get invoked before continuing on
// (keep listening until a second has passed without any msgs)
while (IPC.listen(1000) != IPC.IPC_Timeout) {}
}
// Remove this subscription. You can unsubscribe either by passing
// the handler class, or the handler object itself (see below).
System.out.println("\nIPC.unsubscribe(" + MSG2 + ", msg2Handler)");
IPC.unsubscribe(MSG2, msg2Handler.class);
// If doing direct broadcasts, need to listen to get the direct info update
IPC.listen(250);
// No longer get notified when handlers are added/removed
System.out.println("\nIPC.unsubscribeHandlerChange(" + MSG2 + ", handlerChangeHandler.class)");
IPC.unsubscribeHandlerChange(MSG2, handlerChangeHandler.class);
System.out.println(" IPC.subscribeData(" + MSG2 + ", new msg2Handler(client2c))");
IPC.subscribeData(MSG2, new msg2Handler("client2b"), String.class);
System.out.println(" IPC.unsubscribe(" + MSG2 + ", msg2Handler)");
IPC.unsubscribe(MSG2, msg2Handler.class);
// Publish the message -- receive one message (for msg1Handler)
msgData = "abcdefg";
System.out.println("\nIPC.publishData(" + MSG2 + ", " + msgData + ")");
if (IPC.publishData(MSG2, msgData) == IPC.IPC_OK) {
IPC.listen(1000);
}
// Java version of IPC differs from C version in how it handles client data
// In Java, the client data is part of the handler class.
System.out.println("\nReplacing client data for msg1Handler of " + MSG1 + " with 'client1b'");
msgHandler1.clientData = "client1b";
// Receive one message (for msg1Handler), but now with new client data.
msgData = "abcde";
System.out.println("\nIPC.publishData(" + MSG1 + ", " + msgData + ")");
if (IPC.publishData(MSG1, msgData) == IPC.IPC_OK) {
IPC.listen(1000);
}
// Remove subscription to "msg1"
System.out.println("\nIPC.unsubscribe(" + MSG1 + ", msg1Handler)");
IPC.unsubscribe(MSG1, msgHandler1);
// If doing direct broadcasts, need to listen to get the direct info update
IPC.listen(250);
// Receive no messages -- IPC.listenClear times out
System.out.println("\nIPC.publishData(" + MSG1 + ", " + msgData + ")");
if (IPC.publishData(MSG1, msgData) == IPC.IPC_OK) {
if (IPC.listen(1000) == IPC.IPC_Timeout) {
System.out.println("Timed out");
}
}
////////////////////////////////////////////////////////////////
// TESTS OF THE QUERY/RESPONSE FUNCTIONS
////////////////////////////////////////////////////////////////
// The handler of QUERY_MSG does two things: It *publishes* a message of
// type MSG2, and it *responds* to the query with a message of type MSG2.
// The published message gets handled only by the subscriber (msg1Handler),
// and the response gets handled only be replyHandler, since a response
// is a directed message.
// NOTE: It is perfectly OK to subscribe to a message before it is defined!
System.out.println("\nIPC.subscribeData(" + QUERY_MSG + ", new queryHandler('qtest'))");
IPC.subscribeData(QUERY_MSG, new queryHandler("qtest"), String.class);
System.out.println("\nIPC.defineMsg(" + QUERY_MSG + ", " + STRING_FORMAT + ")");
IPC.defineMsg(QUERY_MSG, STRING_FORMAT);
// This call allows IPC to send the process 2 messages at a time, rather
// than queueing them in the central server.
// This is needed in this example program because the sender and receiver
// of the query are the same process. If this is taken out, the only
// difference is that the message that is published in queryHandler arrives
// *after* the message responded to (even though it is sent first). This
// function should not be needed when we switch to using point-to-point
// communications (rather than sending via the central server).
IPC.setCapacity(2);
System.out.println(
"\nIPC.queryNotifyData(" + QUERY_MSG + ", 'abcdef', " + "new replyHandler('Notification')");
IPC.queryNotifyData(QUERY_MSG, "abcdef", new replyHandler("Notification"), String.class);
// Make sure all the messages spawned by this query get handled before
// continuing (keep listening until a second has passed without any msgs)
while (IPC.listen(1000) != IPC.IPC_Timeout) {}
;
// This essentially does the same thing as queryNotifyData above, except
// it is blocking, and sets the replyHandle to be the data responded to.
// Don't need to listen, since that is done within queryResponse, but
// could be dangerous to wait forever (if the response never comes ...)
msgData = "abcdef";
System.out.println(
"\nIPC.queryResponseData("
+ QUERY_MSG
+ ", "
+ msgData
+ ", String.class, IPC.IPC_WAIT_FOREVER)");
Object response = IPC.queryResponseData(QUERY_MSG, msgData, String.class, IPC.IPC_WAIT_FOREVER);
if (response != null) {
System.out.println("Blocking Response: " + response);
}
// This one should time out before the response arrives
System.out.println(
"\nIPC.queryResponseData(" + QUERY_MSG + ", " + msgData + ", String.class, 0)");
response = IPC.queryResponseData(QUERY_MSG, msgData, String.class, 0);
if (response != null) {
System.out.println("Blocking Response: " + response);
} else {
// NOTE: Since the function call times out before handling messages,
// (a) The *response* to the query is lost (for good)
// (b) The message *published* in queryHandler is waiting for the
// next time the module listens for messages (which actually
// occurs in IPC.msgFormatter, below).
System.out.println("queryResponse timed out (response is null)");
}
IPC.listenClear(1000);
////////////////////////////////////////////////////////////////
// TESTS OF THE MARSHALLING FUNCTIONS
////////////////////////////////////////////////////////////////
// Define a variable-length message whose format is simply an integer
System.out.println("\nIPC.defineMsg(" + MSG3 + ", " + INT_FORMAT + ")");
IPC.defineMsg(MSG3, INT_FORMAT);
// Define a variable-length message whose format is a string
System.out.println("\nIPC.defineMsg(" + MSG4 + ", " + STRING_FORMAT + ")");
IPC.defineMsg(MSG4, STRING_FORMAT);
// Define a variable-length message whose format is a complex structure
System.out.println("\nIPC.defineMsg(" + MSG5 + ", " + MATRIX_LIST_FORMAT + ")");
IPC.defineMsg(MSG5, MATRIX_LIST_FORMAT);
// Subscribe to each of the above messages, all using the same handler
// Differentiated by the dataClass argument...
System.out.println("\nIPC.subscribeData(" + MSG3 + ", new msg3Handler())");
IPC.subscribeData(MSG3, new msg3Handler(), int.class);
System.out.println("\nIPC.subscribeData(" + MSG4 + ", new msg3Handler())");
IPC.subscribeData(MSG4, new msg3Handler(), String.class);
System.out.println("\nIPC.subscribeData(" + MSG5 + ", new msg3Handler())");
IPC.subscribeData(MSG5, new msg3Handler(), matrix_list.class);
// Publish integer data
int ivalue = 42;
System.out.println("\nIPC.publishData(" + MSG3 + ", " + ivalue + ")");
IPC.publishData(MSG3, ivalue);
IPC.listenClear(1000);
// Publish string data
msgData = "Hello, world";
System.out.println("\nIPC.publishData(" + MSG4 + ", " + msgData + ")");
IPC.publishData(MSG4, msgData);
IPC.listenClear(1000);
// Set up a sample matrix_list structure
matrix_list m1 = new matrix_list();
m1.matrix = new float[][] {{0, 1}, {1, 2}};
m1.matrixName = "TheFirst";
m1.count = 1;
m1.next = new matrix_list();
m1.next.matrix = new float[][] {{1, 2}, {2, 3}};
m1.next.matrixName = "TheSecond";
m1.next.count = 2;
m1.next.next = new matrix_list();
m1.next.next.matrix = new float[][] {{2, 3}, {3, 4}};
m1.next.next.matrixName = "TheThird";
m1.next.next.count = 3;
m1.next.next.next = null;
System.out.println("\nIPC.publishData(" + MSG5 + ", " + m1 + ")");
IPC.publishData(MSG5, m1);
IPC.listenClear(1000);
// Use of IPC.queryResponseData and IPC.respondData --
// Send out a message with a matrix_list format The response is a
// message with the first matrix, but each element incremented by one.
// Define the "query" message
System.out.println("\nIPC.defineMsg(" + QUERY2_MSG + ", " + MATRIX_LIST_FORMAT + ")");
IPC.defineMsg(QUERY2_MSG, MATRIX_LIST_FORMAT);
// Define the "response" message
System.out.println("\nIPC.defineMsg(" + RESPONSE2_MSG + ", " + MATRIX_FORMAT + ")");
IPC.defineMsg(RESPONSE2_MSG, MATRIX_FORMAT);
// Subscribe to query message with automatic unmarshalling
System.out.println("\nIPC.subscribeData(" + QUERY2_MSG + ", new query2Handler())");
IPC.subscribeData(QUERY2_MSG, new query2Handler(), matrix_list.class);
// Set up a sample MATRIX_LIST structure
m1 = new matrix_list();
m1.matrix = new float[][] {{0, 1}, {1, 2}};
m1.matrixName = "TheFirst";
m1.count = 1;
m1.next = null;
// IPC.queryResponseData both marsalls and sends the data structure
System.out.println(
"\nIPC.queryResponseData(" + QUERY2_MSG + ", " + m1 + ", IPC.IPC_WAIT_FOREVER)");
Object matrixReply =
IPC.queryResponseData(QUERY2_MSG, m1, float[][].class, IPC.IPC_WAIT_FOREVER);
if (matrixReply != null)
System.out.println("response data: " + query2Handler.matrixString((float[][]) matrixReply));
else System.out.println("IPC.queryResponseData failed");
/* Subscribe a handler for tty input. Now, typing at the terminal will
echo the input. Typing "q" will quit the program; typing "m" will
send a message; typing "u" will unsubscribe the handler (the program
will no longer listen to input). */
System.out.println("\nIPC.subscribeFD(0, new stdinHnd(FD1))");
IPC.subscribeFD(0, new stdinHnd("FD1"));
System.out.println(
"\nEntering dispatch loop (terminal input is echoed," + " type 'q' to quit,");
System.out.println(" 'm' to send a message," + " 'u' to stop listening to stdin).");
IPC.dispatch();
// Shut down gracefully
IPC.disconnect();
}
