static void CheckFile(const String & path, Queue<String> & codes)
{
FileDataIO dio(muscleFopen(path(), "r"));
if (dio.GetFile())
{
String fileName = path.Substring(GetFilePathSeparator());
PlainTextMessageIOGateway gw;
gw.SetDataIO(DataIORef(&dio, false));
// Read in the file
QueueGatewayMessageReceiver q;
while(gw.DoInput(q) > 0) {/* empty */}
// Now parse the lines, and for any that have LogTime() in them, print out the line and the corresponding code key
uint32 lineNumber = 1;
MessageRef msg;
while(q.RemoveHead(msg) == B_NO_ERROR)
{
const String * line;
for (uint32 i=0; msg()->FindString(PR_NAME_TEXT_LINE, i, &line) == B_NO_ERROR; i++)
{
int32 ltIdx = line->IndexOf("LogTime(");
if (ltIdx >= 0)
{
int32 commentIdx = line->IndexOf("//"); // don't include LogTime() calls that are commented out
if ((commentIdx < 0)||(commentIdx > ltIdx))
{
char buf[128];
muscleSprintf(buf, "[%s] %s:" UINT32_FORMAT_SPEC ": ", SourceCodeLocationKeyToString(GenerateSourceCodeLocationKey(fileName(), lineNumber))(), path(), lineNumber);
codes.AddTail(line->Prepend(buf));
}
}
lineNumber++;
}
}
}
}
// 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;
}