execserver/tools/xsClient.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program Execution Server
 * ---------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief ExecServer Client.
 *//*--------------------------------------------------------------------*/

#include "xsDefs.hpp"
#include "xsProtocol.hpp"
#include "deSocket.hpp"
#include "deUniquePtr.hpp"

#include "deString.h"

#include <memory>
#include <sstream>
#include <fstream>
#include <cstdio>
#include <cstdlib>

using std::string;
using std::vector;

namespace xs
{

typedef de::UniquePtr<Message> ScopedMsgPtr;

class SocketError : public Error
{
public:
	SocketError (deSocketResult result, const char* message, const char* file, int line)
		: Error		(message, deGetSocketResultName(result), file, line)
		, m_result	(result)
	{
	}

	deSocketResult getResult (void) const
	{
		return m_result;
	}

private:
	deSocketResult m_result;
};

// Helpers.
void sendMessage (de::Socket& socket, const Message& message)
{
	// Format message.
	vector<deUint8> buf;
	message.write(buf);

	// Write to socket.
	size_t pos = 0;
	while (pos < buf.size())
	{
		size_t			numLeft		= buf.size() - pos;
		size_t			numSent		= 0;
		deSocketResult	result		= socket.send(&buf[pos], numLeft, &numSent);

		if (result != DE_SOCKETRESULT_SUCCESS)
			throw SocketError(result, "send() failed", __FILE__, __LINE__);

		pos += numSent;
	}
}

void readBytes (de::Socket& socket, vector<deUint8>& dst, size_t numBytes)
{
	size_t numRead = 0;
	dst.resize(numBytes);
	while (numRead < numBytes)
	{
		size_t			numLeft		= numBytes - numRead;
		size_t			curNumRead	= 0;
		deSocketResult	result		= socket.receive(&dst[numRead], numLeft, &curNumRead);

		if (result != DE_SOCKETRESULT_SUCCESS)
			throw SocketError(result, "receive() failed", __FILE__, __LINE__);

		numRead += curNumRead;
	}
}

Message* readMessage (de::Socket& socket)
{
	// Header.
	vector<deUint8> header;
	readBytes(socket, header, MESSAGE_HEADER_SIZE);

	MessageType	type;
	size_t		messageSize;
	Message::parseHeader(&header[0], (int)header.size(), type, messageSize);

	// Simple messages without any data.
	switch (type)
	{
		case MESSAGETYPE_KEEPALIVE:				return new KeepAliveMessage();
		case MESSAGETYPE_PROCESS_STARTED:		return new ProcessStartedMessage();
		default:
			break; // Read message with data.
	}

	vector<deUint8> messageBuf;
	readBytes(socket, messageBuf, messageSize-MESSAGE_HEADER_SIZE);

	switch (type)
	{
		case MESSAGETYPE_HELLO:					return new HelloMessage(&messageBuf[0], (int)messageBuf.size());
		case MESSAGETYPE_TEST:					return new TestMessage(&messageBuf[0], (int)messageBuf.size());
		case MESSAGETYPE_PROCESS_LOG_DATA:		return new ProcessLogDataMessage(&messageBuf[0], (int)messageBuf.size());
		case MESSAGETYPE_INFO:					return new InfoMessage(&messageBuf[0], (int)messageBuf.size());
		case MESSAGETYPE_PROCESS_LAUNCH_FAILED:	return new ProcessLaunchFailedMessage(&messageBuf[0], (int)messageBuf.size());
		case MESSAGETYPE_PROCESS_FINISHED:		return new ProcessFinishedMessage(&messageBuf[0], (int)messageBuf.size());
		default:
			XS_FAIL("Unknown message");
	}
}

class CommandLine
{
public:
	de::SocketAddress	address;
	std::string			program;
	std::string			params;
	std::string			workingDir;
	std::string			caseList;
	std::string			dstFileName;
};

class Client
{
public:
						Client		(const CommandLine& cmdLine);
						~Client		(void);

	void				run			(void);

private:
	const CommandLine&	m_cmdLine;
	de::Socket			m_socket;
};

Client::Client (const CommandLine& cmdLine)
	: m_cmdLine(cmdLine)
{
}

Client::~Client (void)
{
}

void Client::run (void)
{
	// Connect to server.
	m_socket.connect(m_cmdLine.address);

	printf("Connected to %s:%d!\n", m_cmdLine.address.getHost(), m_cmdLine.address.getPort());

	// Open result file.
	std::fstream out(m_cmdLine.dstFileName.c_str(), std::fstream::out|std::fstream::binary);

	printf("  writing to %s\n", m_cmdLine.dstFileName.c_str());

	// Send execution request.
	{
		ExecuteBinaryMessage msg;

		msg.name		= m_cmdLine.program;
		msg.params		= m_cmdLine.params;
		msg.workDir		= m_cmdLine.workingDir;
		msg.caseList	= m_cmdLine.caseList;

		sendMessage(m_socket, msg);
		printf("  execution request sent.\n");
	}

	// Run client loop.
	bool isRunning = true;
	while (isRunning)
	{
		ScopedMsgPtr msg(readMessage(m_socket));

		switch (msg->type)
		{
			case MESSAGETYPE_HELLO:
				printf("  HelloMessage\n");
				break;

			case MESSAGETYPE_KEEPALIVE:
			{
				printf("  KeepAliveMessage\n");

				// Reply with keepalive.
				sendMessage(m_socket, KeepAliveMessage());
				break;
			}

			case MESSAGETYPE_INFO:
				printf("  InfoMessage: '%s'\n", static_cast<InfoMessage*>(msg.get())->info.c_str());
				break;

			case MESSAGETYPE_PROCESS_STARTED:
				printf("  ProcessStartedMessage\n");
				break;

			case MESSAGETYPE_PROCESS_FINISHED:
				printf("  ProcessFinished: exit code = %d\n", static_cast<ProcessFinishedMessage*>(msg.get())->exitCode);
				isRunning = false;
				break;

			case MESSAGETYPE_PROCESS_LAUNCH_FAILED:
				printf("  ProcessLaunchFailed: '%s'\n", static_cast<ProcessLaunchFailedMessage*>(msg.get())->reason.c_str());
				isRunning = false;
				break;

			case MESSAGETYPE_PROCESS_LOG_DATA:
			{
				ProcessLogDataMessage* logDataMsg = static_cast<ProcessLogDataMessage*>(msg.get());
				printf("  ProcessLogDataMessage: %d bytes\n", (int)logDataMsg->logData.length());
				out << logDataMsg->logData;
				break;
			}

			default:
				XS_FAIL("Unknown message");
				break;
		}
	}

	// Close output file.
	out.close();

	// Close connection.
	m_socket.shutdown();
	m_socket.close();

	printf("Done!\n");
}

string parseString (const char* str)
{
	if (str[0] == '\'' || str[0] == '"')
	{
		const char*			p		= str;
		char				endChar = *p++;
		std::ostringstream	o;

		while (*p != endChar && *p)
		{
			if (*p == '\\')
			{
				switch (p[1])
				{
					case 0:		DE_ASSERT(DE_FALSE);	break;
					case 'n':	o << '\n';				break;
					case 't':	o << '\t';				break;
					default:	o << p[1];				break;
				}

				p += 2;
			}
			else
				o << *p++;
		}

		return o.str();
	}
	else
		return string(str);
}

void printHelp (const char* binName)
{
	printf("%s:\n", binName);
	printf("  --host=[host]          Connect to host [host]\n");
	printf("  --port=[name]          Use port [port]\n");
	printf("  --program=[program]    Test program\n");
	printf("  --params=[params]      Test program params\n");
	printf("  --workdir=[dir]        Working directory\n");
	printf("  --caselist=[caselist]  Test case list\n");
	printf("  --out=filename         Test result file\n");
}

int runClient (int argc, const char* const* argv)
{
	CommandLine cmdLine;

	// Defaults.
	cmdLine.address.setHost("127.0.0.1");
	cmdLine.address.setPort(50016);
	cmdLine.dstFileName = "TestResults.qpa";

	// Parse command line.
	for (int argNdx = 1; argNdx < argc; argNdx++)
	{
		const char* arg = argv[argNdx];

		if (deStringBeginsWith(arg, "--port="))
			cmdLine.address.setPort(atoi(arg+7));
		else if (deStringBeginsWith(arg, "--host="))
			cmdLine.address.setHost(parseString(arg+7).c_str());
		else if (deStringBeginsWith(arg, "--program="))
			cmdLine.program = parseString(arg+10);
		else if (deStringBeginsWith(arg, "--params="))
			cmdLine.params = parseString(arg+9);
		else if (deStringBeginsWith(arg, "--workdir="))
			cmdLine.workingDir = parseString(arg+10);
		else if (deStringBeginsWith(arg, "--caselist="))
			cmdLine.caseList = parseString(arg+11);
		else if  (deStringBeginsWith(arg, "--out="))
			cmdLine.dstFileName = parseString(arg+6);
		else
		{
			printHelp(argv[0]);
			return -1;
		}
	}

	// Run client.
	try
	{
		Client client(cmdLine);
		client.run();
	}
	catch (const std::exception& e)
	{
		printf("%s\n", e.what());
		return -1;
	}

	return 0;
}

} // xs

int main (int argc, const char* const* argv)
{
	return xs::runClient(argc, argv);
}