static status_t DoSession(const String aDesc, DataIO & aIO, const String & bDesc, DataIO & bIO)
{
Queue<ByteBufferRef> outgoingBData;
Queue<ByteBufferRef> outgoingAData;
uint32 bIndex = 0, aIndex = 0;
SocketMultiplexer multiplexer;
while(true)
{
int aReadFD = aIO.GetReadSelectSocket().GetFileDescriptor();
int bReadFD = bIO.GetReadSelectSocket().GetFileDescriptor();
int aWriteFD = aIO.GetWriteSelectSocket().GetFileDescriptor();
int bWriteFD = bIO.GetWriteSelectSocket().GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(aReadFD);
multiplexer.RegisterSocketForReadReady(bReadFD);
if (outgoingAData.HasItems()) multiplexer.RegisterSocketForWriteReady(aWriteFD);
if (outgoingBData.HasItems()) multiplexer.RegisterSocketForWriteReady(bWriteFD);
if (multiplexer.WaitForEvents() >= 0)
{
if (ReadIncomingData( aDesc, aIO, multiplexer, outgoingBData) != B_NO_ERROR) return B_ERROR;
if (ReadIncomingData( bDesc, bIO, multiplexer, outgoingAData) != B_NO_ERROR) return B_ERROR;
if (WriteOutgoingData(aDesc, aIO, multiplexer, outgoingAData, aIndex) != B_NO_ERROR) return B_ERROR;
if (WriteOutgoingData(bDesc, bIO, multiplexer, outgoingBData, bIndex) != B_NO_ERROR) return B_ERROR;
}
else
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Error, WaitForEvents() failed!\n");
return B_ERROR;
}
}
}
static status_t WriteOutgoingData(const String & desc, DataIO & writeIO, const SocketMultiplexer & multiplexer, Queue<ByteBufferRef> & outQ, uint32 & writeIdx)
{
if (multiplexer.IsSocketReadyForWrite(writeIO.GetWriteSelectSocket().GetFileDescriptor()))
{
while(outQ.HasItems())
{
ByteBufferRef & firstBuf = outQ.Head();
uint32 bufSize = firstBuf()->GetNumBytes();
if (writeIdx >= bufSize)
{
outQ.RemoveHead();
writeIdx = 0;
}
else
{
int32 ret = writeIO.Write(firstBuf()->GetBuffer()+writeIdx, firstBuf()->GetNumBytes()-writeIdx);
if (ret > 0)
{
writeIO.FlushOutput();
LogTime(MUSCLE_LOG_TRACE, "Wrote " INT32_FORMAT_SPEC " bytes to %s:\n", ret, desc());
LogHexBytes(MUSCLE_LOG_TRACE, firstBuf()->GetBuffer()+writeIdx, ret);
writeIdx += ret;
}
else if (ret < 0) LogTime(MUSCLE_LOG_ERROR, "Error, writeIO.Write() returned %i\n", ret);
}
}
}
return B_NO_ERROR;
}
static status_t DoSession(DataIO & networkIO, DataIO & serialIO)
{
Queue<ByteBufferRef> outgoingSerialData;
Queue<ByteBufferRef> outgoingNetworkData;
uint32 serialIndex = 0, networkIndex = 0;
SocketMultiplexer multiplexer;
while(true)
{
int networkReadFD = networkIO.GetReadSelectSocket().GetFileDescriptor();
int serialReadFD = serialIO.GetReadSelectSocket().GetFileDescriptor();
int networkWriteFD = networkIO.GetWriteSelectSocket().GetFileDescriptor();
int serialWriteFD = serialIO.GetWriteSelectSocket().GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(networkReadFD);
multiplexer.RegisterSocketForReadReady(serialReadFD);
if (outgoingNetworkData.HasItems()) multiplexer.RegisterSocketForWriteReady(networkWriteFD);
if (outgoingSerialData.HasItems()) multiplexer.RegisterSocketForWriteReady(serialWriteFD);
if (multiplexer.WaitForEvents() >= 0)
{
if (ReadIncomingData("network", networkIO, multiplexer, outgoingSerialData) != B_NO_ERROR) return B_NO_ERROR; // tells main() to wait for the next TCP connection
if (ReadIncomingData("serial", serialIO, multiplexer, outgoingNetworkData) != B_NO_ERROR) return B_ERROR; // tells main() to exit
if (WriteOutgoingData("network", networkIO, multiplexer, outgoingNetworkData, networkIndex) != B_NO_ERROR) return B_NO_ERROR; // tells main() to wait for the next TCP connection
if (WriteOutgoingData("serial", serialIO, multiplexer, outgoingSerialData, serialIndex) != B_NO_ERROR) return B_ERROR; // tells main() to exit
}
else
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Error, WaitForEvents() failed!\n");
return B_ERROR;
}
}
}
static status_t ReadIncomingData(const String & desc, DataIO & readIO, const SocketMultiplexer & multiplexer, Queue<ByteBufferRef> & outQ)
{
if (multiplexer.IsSocketReadyForRead(readIO.GetReadSelectSocket().GetFileDescriptor()))
{
uint8 buf[4096];
int32 ret = readIO.Read(buf, sizeof(buf));
if (ret > 0)
{
LogTime(MUSCLE_LOG_TRACE, "Read " INT32_FORMAT_SPEC " bytes from %s:\n", ret, desc());
LogHexBytes(MUSCLE_LOG_TRACE, buf, ret);
ByteBufferRef toNetworkBuf = GetByteBufferFromPool(ret, buf);
if (toNetworkBuf()) (void) outQ.AddTail(toNetworkBuf);
}
else if (ret < 0) {LogTime(MUSCLE_LOG_ERROR, "Error, readIO.Read() returned %i\n", ret); return B_ERROR;}
}
return B_NO_ERROR;
}
// This program is equivalent to the portableplaintext client, except
// that we communicate with a child process instead of a socket.
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
if (argc < 3) PrintUsageAndExit();
const uint32 numProcesses = atol(argv[1]);
if (numProcesses == 0) PrintUsageAndExit();
const char * cmd = argv[2];
Hashtable<String,String> testEnvVars;
(void) testEnvVars.Put("Peanut Butter", "Jelly");
(void) testEnvVars.Put("Jelly", "Peanut Butter");
(void) testEnvVars.Put("Oranges", "Grapes");
Queue<DataIORef> refs;
for (uint32 i=0; i<numProcesses; i++)
{
ChildProcessDataIO * dio = new ChildProcessDataIO(false);
refs.AddTail(DataIORef(dio));
printf("About To Launch child process #" UINT32_FORMAT_SPEC ": [%s]\n", i+1, cmd); fflush(stdout);
ConstSocketRef s = (dio->LaunchChildProcess(argc-2, ((const char **) argv)+2, ChildProcessLaunchFlags(MUSCLE_DEFAULT_CHILD_PROCESS_LAUNCH_FLAGS), NULL, &testEnvVars) == B_NO_ERROR) ? dio->GetReadSelectSocket() : ConstSocketRef();
printf("Finished Launching child process #" UINT32_FORMAT_SPEC ": [%s]\n", i+1, cmd); fflush(stdout);
if (s() == NULL)
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Error launching child process #" UINT32_FORMAT_SPEC " [%s]!\n", i+1, cmd);
return 10;
}
}
StdinDataIO stdinIO(false);
PlainTextMessageIOGateway stdinGateway;
QueueGatewayMessageReceiver stdinInputQueue;
stdinGateway.SetDataIO(DataIORef(&stdinIO, false));
SocketMultiplexer multiplexer;
for (uint32 i=0; i<refs.GetNumItems(); i++)
{
printf("------------ CHILD PROCESS #" UINT32_FORMAT_SPEC " ------------------\n", i+1);
PlainTextMessageIOGateway ioGateway;
ioGateway.SetDataIO(refs[i]);
ConstSocketRef readSock = refs[i]()->GetReadSelectSocket();
QueueGatewayMessageReceiver ioInputQueue;
while(1)
{
int readFD = readSock.GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(readFD);
const int writeFD = ioGateway.HasBytesToOutput() ? refs[i]()->GetWriteSelectSocket().GetFileDescriptor() : -1;
if (writeFD >= 0) multiplexer.RegisterSocketForWriteReady(writeFD);
const int stdinFD = stdinIO.GetReadSelectSocket().GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(stdinFD);
if (multiplexer.WaitForEvents() < 0) printf("testchildprocess: WaitForEvents() failed!\n");
// First, deliver any lines of text from stdin to the child process
if ((multiplexer.IsSocketReadyForRead(stdinFD))&&(stdinGateway.DoInput(ioGateway) < 0))
{
printf("Error reading from stdin, aborting!\n");
break;
}
const bool reading = multiplexer.IsSocketReadyForRead(readFD);
const bool writing = ((writeFD >= 0)&&(multiplexer.IsSocketReadyForWrite(writeFD)));
const bool writeError = ((writing)&&(ioGateway.DoOutput() < 0));
const bool readError = ((reading)&&(ioGateway.DoInput(ioInputQueue) < 0));
if ((readError)||(writeError))
{
printf("Connection closed, exiting.\n");
break;
}
MessageRef incoming;
while(ioInputQueue.RemoveHead(incoming) == B_NO_ERROR)
{
printf("Heard message from server:-----------------------------------\n");
const char * inStr;
for (int i=0; (incoming()->FindString(PR_NAME_TEXT_LINE, i, &inStr) == B_NO_ERROR); i++) printf("Line %i: [%s]\n", i, inStr);
printf("-------------------------------------------------------------\n");
}
if ((reading == false)&&(writing == false)) break;
multiplexer.RegisterSocketForReadReady(readFD);
if (ioGateway.HasBytesToOutput()) multiplexer.RegisterSocketForWriteReady(writeFD);
}
if (ioGateway.HasBytesToOutput())
{
printf("Waiting for all pending messages to be sent...\n");
while((ioGateway.HasBytesToOutput())&&(ioGateway.DoOutput() >= 0)) {printf ("."); fflush(stdout);}
}
}
printf("\n\nBye!\n");
return 0;
}
// This is a text based test client for the muscled server. It is useful for testing
// the server, and could possibly be useful for other things, I don't know.
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
String hostName;
uint16 port = 2960;
if (argc > 1) ParseConnectArg(argv[1], hostName, port, false);
ConstSocketRef sock = Connect(hostName(), port, "portablereflectclient", false);
if (sock() == NULL) return 10;
// We'll receive plain text over stdin
StdinDataIO stdinIO(false);
PlainTextMessageIOGateway stdinGateway;
stdinGateway.SetDataIO(DataIORef(&stdinIO, false));
// And send and receive flattened Message objects over our TCP socket
TCPSocketDataIO tcpIO(sock, false);
MessageIOGateway tcpGateway;
tcpGateway.SetDataIO(DataIORef(&tcpIO, false));
DataIORef networkIORef(&tcpIO, false);
AbstractMessageIOGatewayRef gatewayRef(&tcpGateway, false);
#ifdef MUSCLE_ENABLE_SSL
for (int i=1; i<argc; i++)
{
const char * a = argv[i];
if (strncmp(a, "publickey=", 10) == 0)
{
a += 10; // skip past the 'publickey=' part
SSLSocketDataIO * sslIO = new SSLSocketDataIO(sock, false, false);
DataIORef sslIORef(sslIO);
if (sslIO->SetPublicKeyCertificate(a) == B_NO_ERROR)
{
LogTime(MUSCLE_LOG_INFO, "Using public key certificate file [%s] to connect to server\n", a);
networkIORef = sslIORef;
gatewayRef.SetRef(new SSLSocketAdapterGateway(gatewayRef));
gatewayRef()->SetDataIO(networkIORef);
}
else
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Couldn't load public key certificate file [%s] (file not found?)\n", a);
return 10;
}
}
}
#endif
SocketMultiplexer multiplexer;
QueueGatewayMessageReceiver stdinInQueue, tcpInQueue;
bool keepGoing = true;
uint64 nextTimeoutTime = MUSCLE_TIME_NEVER;
while(keepGoing)
{
const int stdinFD = stdinIO.GetReadSelectSocket().GetFileDescriptor();
const int socketReadFD = networkIORef()->GetReadSelectSocket().GetFileDescriptor();
const int socketWriteFD = networkIORef()->GetWriteSelectSocket().GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(stdinFD);
multiplexer.RegisterSocketForReadReady(socketReadFD);
if (gatewayRef()->HasBytesToOutput()) multiplexer.RegisterSocketForWriteReady(socketWriteFD);
if (multiplexer.WaitForEvents(nextTimeoutTime) < 0) printf("portablereflectclient: WaitForEvents() failed!\n");
const uint64 now = GetRunTime64();
if (now >= nextTimeoutTime)
{
// For OpenSSL testing: Generate some traffic to the server every 50mS
printf("Uploading timed OpenSSL-tester update at time " UINT64_FORMAT_SPEC "\n", now);
MessageRef stateMsg = GetMessageFromPool();
stateMsg()->AddString("username", "portablereflectclient");
stateMsg()->AddPoint("position", Point((rand()%100)/100.0f, (rand()%100)/100.0f));
stateMsg()->AddInt32("color", -1);
MessageRef uploadMsg = GetMessageFromPool(PR_COMMAND_SETDATA);
uploadMsg()->AddMessage("qt_example/state", stateMsg);
gatewayRef()->AddOutgoingMessage(uploadMsg);
nextTimeoutTime = now + MillisToMicros(50);
}
// Receive data from stdin
if (multiplexer.IsSocketReadyForRead(stdinFD))
{
while(1)
{
const int32 bytesRead = stdinGateway.DoInput(stdinInQueue);
if (bytesRead < 0)
{
printf("Stdin closed, exiting!\n");
keepGoing = false;
break;
}
else if (bytesRead == 0) break; // no more to read
}
}
// Handle any input lines that were received from stdin
MessageRef msgFromStdin;
while(stdinInQueue.RemoveHead(msgFromStdin) == B_NO_ERROR)
{
const String * st;
for (int32 i=0; msgFromStdin()->FindString(PR_NAME_TEXT_LINE, i, &st) == B_NO_ERROR; i++)
{
const char * text = st->Cstr();
printf("You typed: [%s]\n", text);
bool send = true;
MessageRef ref = GetMessageFromPool();
const char * arg1 = (st->Length()>2) ? &text[2] : NULL;
switch(text[0])
{
case 'm':
ref()->what = MAKETYPE("umsg");
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
ref()->AddString("info", "This is a user message");
break;
case 'i':
ref()->what = PR_COMMAND_PING;
ref()->AddString("Test ping", "yeah");
break;
case 's':
{
ref()->what = PR_COMMAND_SETDATA;
MessageRef uploadMsg = GetMessageFromPool(MAKETYPE("HELO"));
uploadMsg()->AddString("This node was posted at: ", GetHumanReadableTimeString(GetRunTime64()));
if (arg1) ref()->AddMessage(arg1, uploadMsg);
}
break;
case 'k':
ref()->what = PR_COMMAND_KICK;
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
break;
case 'b':
ref()->what = PR_COMMAND_ADDBANS;
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
break;
case 'B':
ref()->what = PR_COMMAND_REMOVEBANS;
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
break;
case 'g':
ref()->what = PR_COMMAND_GETDATA;
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
break;
case 'G':
ref()->what = PR_COMMAND_GETDATATREES;
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
ref()->AddString(PR_NAME_TREE_REQUEST_ID, "Tree ID!");
break;
case 'q':
keepGoing = send = false;
break;
case 'p':
ref()->what = PR_COMMAND_SETPARAMETERS;
if (arg1) ref()->AddString(arg1, "");
break;
case 'P':
ref()->what = PR_COMMAND_GETPARAMETERS;
break;
case 'L':
{
// simulate the behavior of qt_example, for testing OpenSSL problem
ref()->what = PR_COMMAND_SETPARAMETERS;
ref()->AddBool("SUBSCRIBE:qt_example/state", true);
printf("Starting OpenSSL problem test...\n");
nextTimeoutTime = 0;
}
break;
case 'x':
{
ref()->what = PR_COMMAND_SETPARAMETERS;
StringQueryFilter sqf("sc_tstr", StringQueryFilter::OP_SIMPLE_WILDCARD_MATCH, "*Output*");
ref()->AddArchiveMessage("SUBSCRIBE:/*/*/csproj/default/subcues/*", sqf);
}
break;
case 'd':
ref()->what = PR_COMMAND_REMOVEDATA;
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
break;
case 'D':
ref()->what = PR_COMMAND_REMOVEPARAMETERS;
if (arg1) ref()->AddString(PR_NAME_KEYS, arg1);
break;
case 't':
{
// test all data types
ref()->what = 1234;
ref()->AddString("String", "this is a string");
ref()->AddInt8("Int8", 123);
ref()->AddInt8("-Int8", -123);
ref()->AddInt16("Int16", 1234);
ref()->AddInt16("-Int16", -1234);
ref()->AddInt32("Int32", 12345);
ref()->AddInt32("-Int32", -12345);
ref()->AddInt64("Int64", 123456789);
ref()->AddInt64("-Int64", -123456789);
ref()->AddBool("Bool", true);
ref()->AddBool("-Bool", false);
ref()->AddFloat("Float", 1234.56789f);
ref()->AddFloat("-Float", -1234.56789f);
ref()->AddDouble("Double", 1234.56789);
ref()->AddDouble("-Double", -1234.56789);
ref()->AddPointer("Pointer", ref());
ref()->AddFlat("Flat", *ref());
char data[] = "This is some data";
ref()->AddData("Flat", B_RAW_TYPE, data, sizeof(data));
}
break;
default:
printf("Sorry, wot?\n");
send = false;
break;
}
if (send)
{
printf("Sending message...\n");
ref()->PrintToStream();
gatewayRef()->AddOutgoingMessage(ref);
}
}
}
// Handle input and output on the TCP socket
const bool reading = multiplexer.IsSocketReadyForRead(socketReadFD);
const bool writing = multiplexer.IsSocketReadyForWrite(socketWriteFD);
const bool writeError = ((writing)&&(gatewayRef()->DoOutput() < 0));
const bool readError = ((reading)&&(gatewayRef()->DoInput(tcpInQueue) < 0));
if ((readError)||(writeError))
{
printf("Connection closed (%s), exiting.\n", writeError?"Write Error":"Read Error");
keepGoing = false;
}
MessageRef msgFromTCP;
while(tcpInQueue.RemoveHead(msgFromTCP) == B_NO_ERROR)
{
printf("Heard message from server:-----------------------------------\n");
msgFromTCP()->PrintToStream();
printf("-------------------------------------------------------------\n");
}
}
if (gatewayRef()->HasBytesToOutput())
{
printf("Waiting for all pending messages to be sent...\n");
while((gatewayRef()->HasBytesToOutput())&&(gatewayRef()->DoOutput() >= 0)) {printf ("."); fflush(stdout);}
}
printf("\n\nBye!\n");
return 0;
}
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
PrintExampleDescription();
// Let's enable a bit of debug-output, just to see what the client is doing
SetConsoleLogLevel(MUSCLE_LOG_DEBUG);
MessageTransceiverThread mtt;
if (mtt.StartInternalThread() != B_NO_ERROR)
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Couldn't start the MessageTransceiverThread, aborting!\n");
return 10;
}
if (mtt.AddNewConnectSession(localhostIP, SMART_SERVER_TCP_PORT, SecondsToMicros(1)) != B_NO_ERROR)
{
LogTime(MUSCLE_LOG_CRITICALERROR, "mtt.AddNewConnectSession() failed, aborting!\n");
mtt.ShutdownInternalThread();
return 10;
}
LogTime(MUSCLE_LOG_INFO, "This program is designed to be run in conjunction with example_4_smart_server\n");
LogTime(MUSCLE_LOG_INFO, "You'll probably want to run multiple instances of this client at the same time, also.\n");
printf("\n");
PrintHelp();
printf("\n");
LogTime(MUSCLE_LOG_INFO, "Some example commands that you can enter:\n");
LogTime(MUSCLE_LOG_INFO, " subscribe /*/* -> will set up a subscription that always lets you know who is connected\n");
LogTime(MUSCLE_LOG_INFO, " subscribe /*/*/* -> will set up a subscription that always lets you know who set/deleted/updated a node\n");
LogTime(MUSCLE_LOG_INFO, " subscribe * -> is the same as the previous command (the initial wildcards can be implicit)\n");
LogTime(MUSCLE_LOG_INFO, " set frood = groovy -> create a node named 'frood' in your session-folder, with the word 'groovy' in its Message\n");
LogTime(MUSCLE_LOG_INFO, " delete frood -> delete the node named 'frood' in your session-folder\n");
LogTime(MUSCLE_LOG_INFO, " delete f* -> delete all nodes in your session-folder whose names start with f\n");
LogTime(MUSCLE_LOG_INFO, " delete * -> delete all nodes in your session-folder\n");
LogTime(MUSCLE_LOG_INFO, " msg /*/* hello -> say hello to everyone who is connected\n");
LogTime(MUSCLE_LOG_INFO, " msg /*/*/frood hello -> say hello to everyone who is connected and created a node named \'frood\' in their session-folder\n");
LogTime(MUSCLE_LOG_INFO, " die -> cause the client process to exit\n");
printf("\n");
// Run our own event loop to read from stdin and retrieve
// feedback events from the MessageTransceiverThread.
// (In other contexts this might be a QEventLoop or
// a Win32 event loop or an SDL event loop or etc; anything
// where the main thread needs to be doing some non-MUSCLE
// event loop is a good use case for QMessageTransceiverThread)
StdinDataIO stdinIO(false);
SocketMultiplexer sm;
while(true)
{
sm.RegisterSocketForReadReady(stdinIO.GetReadSelectSocket().GetFileDescriptor());
sm.RegisterSocketForReadReady(mtt.GetOwnerWakeupSocket().GetFileDescriptor());
sm.WaitForEvents();
if (sm.IsSocketReadyForRead(stdinIO.GetReadSelectSocket().GetFileDescriptor()))
{
// Handle stdin input, and send a Message to the MessageTransceiverThread
// for it to send on to the server, if appropriate
uint8 inputBuf[1024];
const int numBytesRead = stdinIO.Read(inputBuf, sizeof(inputBuf)-1);
if (numBytesRead > 0)
{
String inputCmd((const char *) inputBuf, numBytesRead);
inputCmd = inputCmd.Trim();
if (inputCmd == "die") break;
MessageRef msgToSend = ParseStdinCommand(inputCmd);
if (msgToSend())
{
printf("Calling mtt.SendMessageToSessions() with the following Message:\n");
msgToSend()->PrintToStream();
(void) mtt.SendMessageToSessions(msgToSend);
}
}
else if (numBytesRead < 0) break;
}
if (sm.IsSocketReadyForRead(mtt.GetOwnerWakeupSocket().GetFileDescriptor()))
{
// Handle any feedback events sent back to us from the MessageTransceiverThread
uint32 code;
MessageRef ref;
String session;
uint32 factoryID;
IPAddressAndPort location;
while(mtt.GetNextEventFromInternalThread(code, &ref, &session, &factoryID, &location) >= 0)
{
String codeStr;
switch(code)
{
case MTT_EVENT_INCOMING_MESSAGE: codeStr = "IncomingMessage"; break;
case MTT_EVENT_SESSION_ACCEPTED: codeStr = "SessionAccepted"; break;
case MTT_EVENT_SESSION_ATTACHED: codeStr = "SessionAttached"; break;
case MTT_EVENT_SESSION_CONNECTED: codeStr = "SessionConnected"; break;
case MTT_EVENT_SESSION_DISCONNECTED: codeStr = "SessionDisconnected"; break;
case MTT_EVENT_SESSION_DETACHED: codeStr = "SessionDetached"; break;
case MTT_EVENT_FACTORY_ATTACHED: codeStr = "FactoryAttached"; break;
case MTT_EVENT_FACTORY_DETACHED: codeStr = "FactoryDetached"; break;
case MTT_EVENT_OUTPUT_QUEUES_DRAINED: codeStr = "OutputQueuesDrained"; break;
case MTT_EVENT_SERVER_EXITED: codeStr = "ServerExited"; break;
default: codeStr = String("\'%1\'").Arg(GetTypeCodeString(code)); break;
}
printf("Event from MTT: type=[%s], session=[%s] factoryID=[" UINT32_FORMAT_SPEC "] location=[%s]\n", codeStr(), session(), factoryID, location.ToString()());
if (ref()) ref()->PrintToStream();
}
}
}
mtt.ShutdownInternalThread();
return 0;
}
void HandleSession(const ConstSocketRef & sock, bool myTurnToThrow, bool doFlush)
{
LogTime(MUSCLE_LOG_ERROR, "Beginning catch session (%s)\n", doFlush?"flush enabled":"flush disabled");
TCPSocketDataIO sockIO(sock, false);
uint64 lastThrowTime = 0;
uint8 ball = 'B'; // this is what we throw back and forth over the TCP socket!
uint64 min=((uint64)-1), max=0;
uint64 lastPrintTime = 0;
uint64 count = 0;
uint64 total = 0;
SocketMultiplexer multiplexer;
while(1)
{
int fd = sock.GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(fd);
if (myTurnToThrow) multiplexer.RegisterSocketForWriteReady(fd);
if (multiplexer.WaitForEvents() < 0)
{
LogTime(MUSCLE_LOG_ERROR, "WaitForEvents() failed, aborting!\n");
break;
}
if ((myTurnToThrow)&&(multiplexer.IsSocketReadyForWrite(fd)))
{
int32 bytesWritten = sockIO.Write(&ball, sizeof(ball));
if (bytesWritten == sizeof(ball))
{
if (doFlush) sockIO.FlushOutput(); // nagle's algorithm gets toggled here!
lastThrowTime = GetRunTime64();
myTurnToThrow = false; // we thew the ball, now wait to catch it again!
}
else if (bytesWritten < 0)
{
LogTime(MUSCLE_LOG_ERROR, "Error sending ball, aborting!\n");
break;
}
}
if (multiplexer.IsSocketReadyForRead(fd))
{
int32 bytesRead = sockIO.Read(&ball, sizeof(ball));
if (bytesRead == sizeof(ball))
{
if (myTurnToThrow == false)
{
if (lastThrowTime > 0)
{
uint64 elapsedTime = GetRunTime64() - lastThrowTime;
count++;
total += elapsedTime;
min = muscleMin(min, elapsedTime);
max = muscleMax(max, elapsedTime);
if (OnceEvery(MICROS_PER_SECOND, lastPrintTime)) LogTime(MUSCLE_LOG_INFO, "count=" UINT64_FORMAT_SPEC" min=" UINT64_FORMAT_SPEC "us max=" UINT64_FORMAT_SPEC "us avg=" UINT64_FORMAT_SPEC "us\n", count, min, max, total/count);
}
myTurnToThrow = true; // we caught the ball, now throw it back!
}
}
else if (bytesRead < 0)
{
LogTime(MUSCLE_LOG_ERROR, "Error reading ball, aborting!\n");
break;
}
}
}
}
// This program tests the SocketMultiplexer class by seeing how many chained socket-pairs
// we can chain a message through sequentially
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
uint32 numPairs = 5;
if (argc > 1) numPairs = atoi(argv[1]);
bool quiet = false;
if ((argc > 2)&&(strcmp(argv[2], "quiet") == 0)) quiet = true;
#ifdef __APPLE__
// Tell MacOS/X that yes, we really do want to create this many file descriptors
struct rlimit rl;
rl.rlim_cur = rl.rlim_max = (numPairs*2)+5;
if (setrlimit(RLIMIT_NOFILE, &rl) != 0) perror("setrlimit");
#endif
printf("Testing %i socket-pairs chained together...\n", numPairs);
Queue<ConstSocketRef> senders; (void) senders.EnsureSize(numPairs, true);
Queue<ConstSocketRef> receivers; (void) receivers.EnsureSize(numPairs, true);
for (uint32 i=0; i<numPairs; i++)
{
if (CreateConnectedSocketPair(senders[i], receivers[i]) != B_NO_ERROR)
{
printf("Error, failed to create socket pair #" UINT32_FORMAT_SPEC "!\n", i);
return 10;
}
}
// Start the game off
char c = 'C';
if (SendData(senders[0], &c, 1, false) != 1)
{
printf("Error, couldn't send initial byte!\n");
return 10;
}
uint64 count = 0;
uint64 tally = 0;
uint64 minRunTime = (uint64)-1;
uint64 maxRunTime = 0;
SocketMultiplexer multiplexer;
uint64 endTime = GetRunTime64() + SecondsToMicros(10);
bool error = false;
while(error==false)
{
for (uint32 i=0; i<numPairs; i++)
{
if (multiplexer.RegisterSocketForReadReady(receivers[i].GetFileDescriptor()) != B_NO_ERROR)
{
printf("Error, RegisterSocketForRead() failed for receiver #" UINT32_FORMAT_SPEC "!\n", i);
error = true;
break;
}
}
if (error) break;
uint64 then = GetRunTime64();
if (then >= endTime) break;
int ret = multiplexer.WaitForEvents();
if (ret < 0)
{
printf("WaitForEvents errored out, aborting test!\n");
break;
}
uint64 elapsed = GetRunTime64()-then;
if (quiet == false) printf("WaitForEvents returned %i after " UINT64_FORMAT_SPEC " microseconds.\n", ret, elapsed);
count++;
tally += elapsed;
minRunTime = muscleMin(minRunTime, elapsed);
maxRunTime = muscleMax(maxRunTime, elapsed);
for (uint32 i=0; i<numPairs; i++)
{
if (multiplexer.IsSocketReadyForRead(receivers[i].GetFileDescriptor()))
{
char buf[64];
int32 numBytesReceived = ReceiveData(receivers[i], buf, sizeof(buf), false);
if (quiet == false) printf("Receiver #" UINT32_FORMAT_SPEC " signalled ready-for-read, read " INT32_FORMAT_SPEC " bytes.\n", i, numBytesReceived);
if (numBytesReceived > 0)
{
uint32 nextIdx = (i+1)%numPairs;
int32 sentBytes = SendData(senders[nextIdx], buf, numBytesReceived, false);
if (quiet == false) printf("Sent " INT32_FORMAT_SPEC " bytes on sender #" UINT32_FORMAT_SPEC "\n", sentBytes, nextIdx);
}
}
}
}
printf("Test complete: WaitEvents() called " UINT64_FORMAT_SPEC " times, averageTime=" UINT64_FORMAT_SPEC "uS, minimumTime=" UINT64_FORMAT_SPEC "uS, maximumTime=" UINT64_FORMAT_SPEC "uS.\n", count, tally/(count?count:1), minRunTime, maxRunTime);
return 0;
}
