haiku.git

// AppRunner.cpp

#include <errno.h>
#include <stdlib.h>
#include <unistd.h>

#include <Autolock.h>
#include <Entry.h>
#include <Messenger.h>
#include <String.h>

#include <TestShell.h>
#include <TestUtils.h>
#include <cppunit/TestAssert.h>

#include "AppRunner.h"

static const char *kAppRunnerTeamPort = "app runner team port";

// constructor
AppRunner::AppRunner(bool requestQuitOnDestruction)
		 : fOutputLock(),
		   fRemotePort(-1),
		   fOutput(),
		   fReader(-1),
		   fTeam(-1),
		   fRef(),
		   fMessenger(),
		   fRequestQuitOnDestruction(requestQuitOnDestruction)
{
}

// destructor
AppRunner::~AppRunner()
{
	if (fRequestQuitOnDestruction)
		WaitFor(true);
	if (fReader >= 0) {
		int32 result;
		wait_for_thread(fReader, &result);
	}
}

// Run
status_t
AppRunner::Run(const char *command, const char *args, bool findCommand)
{
	status_t error = (HasQuitted() ? B_OK : B_ERROR);
	// get the app path
	BString appPath;
	if (findCommand) {
		find_test_app(command, &appPath);
		command = appPath.String();
	}
	get_ref_for_path(command, &fRef);
	// add args, i.e. compose the command line
	BString cmdLine(command);
	if (args) {
		cmdLine += " ";
		cmdLine += args;
	}
	// lock the team port
	bool teamPortLocked = false;
	if (error == B_OK) {
		teamPortLocked = _LockTeamPort();
		if (!teamPortLocked)
			error = B_ERROR;
	}
	// run the command
	if (error == B_OK) {
		cmdLine += " &";
		if (system(cmdLine.String()) != 0)
			error = errno;
	}
	// read the port ID
	if (error == B_OK) {
		fRemotePort = _ReadPortID(fMessenger);
		if (fRemotePort < 0)
			error = fRemotePort;
	}
	// unlock the team port
	if (teamPortLocked)
		_UnlockTeamPort();
	// get the team ID
	if (error == B_OK) {
		port_info info;
		error = get_port_info(fRemotePort, &info);
		fTeam = info.team;
	}
	// spawn the reader thread
	if (error == B_OK) {
		fReader = spawn_thread(&_ReaderEntry, "AppRunner reader",
							   B_NORMAL_PRIORITY, (void*)this);
		if (fReader >= 0)
			error = resume_thread(fReader);
		else
			error = fReader;
	}
	// cleanup on error
	if (error != B_OK) {
		if (fReader >= 0) {
			kill_thread(fReader);
			fReader = -1;
		}
	}
	return error;
}

// HasQuitted
bool
AppRunner::HasQuitted()
{
	port_info info;
	return (get_port_info(fRemotePort, &info) != B_OK);
}

// WaitFor
void
AppRunner::WaitFor(bool requestQuit)
{
	if (!HasQuitted() && requestQuit)
		RequestQuit();
	while (!HasQuitted())
		snooze(10000);
}

// Team
team_id
AppRunner::Team()
{
	return fTeam;
}

// AppLooperPort
port_id
AppRunner::AppLooperPort()
{
	struct messenger_hack {
		port_id	fPort;
		int32	fHandlerToken;
		team_id	fTeam;
		int32	extra0;
		int32	extra1;
		bool	fPreferredTarget;
		bool	extra2;
		bool	extra3;
		bool	extra4;
	};
	return ((messenger_hack*)&fMessenger)->fPort;
}

// GetRef
status_t
AppRunner::GetRef(entry_ref *ref)
{
	status_t error = (ref ? B_OK : B_ERROR);
	if (error == B_OK)
		*ref = fRef;
	return error;
}

// RequestQuit
status_t
AppRunner::RequestQuit()
{
	status_t error = B_OK;
	if (fTeam >= 0) {
		BMessenger messenger(fMessenger);
		error = messenger.SendMessage(B_QUIT_REQUESTED);
	} else
		error = fTeam;
	return error;
}

// GetOutput
status_t
AppRunner::GetOutput(BString *buffer)
{
	status_t error = (buffer ? B_OK : B_BAD_VALUE);
	if (error == B_OK) {
		BAutolock locker(fOutputLock);
		size_t size = fOutput.BufferLength();
		const void *output = fOutput.Buffer();
		if (size > 0)
			buffer->SetTo((const char*)output, size);
		else
			*buffer = "";
	}
	return error;
}

// ReadOutput
ssize_t
AppRunner::ReadOutput(void *buffer, size_t size)
{
	BAutolock locker(fOutputLock);
	return fOutput.Read(buffer, size);
}

// ReadOutputAt
ssize_t
AppRunner::ReadOutputAt(off_t position, void *buffer, size_t size)
{
	BAutolock locker(fOutputLock);
	return fOutput.ReadAt(position, buffer, size);
}

// _ReaderEntry
int32
AppRunner::_ReaderEntry(void *data)
{
	int32 result = 0;
	if (AppRunner *me = (AppRunner*)data)
		result = me->_ReaderLoop();
	return result;
}

// _ReaderLoop
int32
AppRunner::_ReaderLoop()
{
	char buffer[10240];
	port_id port = fRemotePort;
	status_t error = B_OK;
	while (error == B_OK) {
		int32 code;
		ssize_t bytes = read_port(port, &code, buffer, sizeof(buffer) - 1);
		if (bytes > 0) {
			// write the buffer
			BAutolock locker(fOutputLock);
			off_t oldPosition = fOutput.Seek(0, SEEK_END);
			fOutput.Write(buffer, bytes);
			fOutput.Seek(oldPosition, SEEK_SET);
		} else if (bytes < 0)
			error = bytes;
	}
	fRemotePort = -1;
	return 0;
}

// _LockTeamPort
bool
AppRunner::_LockTeamPort()
{
	bool result = fTeamPortLock.Lock();
	// lazy port creation
	if (result && fTeamPort < 0) {
		fTeamPort = create_port(5, kAppRunnerTeamPort);
		if (fTeamPort < 0) {
			fTeamPortLock.Unlock();
			result = false;
		}
	}
	return result;
}

// _UnlockTeamPort
void
AppRunner::_UnlockTeamPort()
{
	fTeamPortLock.Unlock();
}

// _ReadPortID
port_id
AppRunner::_ReadPortID(BMessenger &messenger)
{
	port_id port = -1;
	ssize_t size = read_port(fTeamPort, &port, &messenger, sizeof(BMessenger));
	if (size < 0)
		port = size;
	return port;
}


// fTeamPort
port_id	AppRunner::fTeamPort = -1;

// fTeamPortLock
BLocker	AppRunner::fTeamPortLock;


// find_test_app
status_t
find_test_app(const char *testApp, BString *path)
{
	status_t error = (testApp && path ? B_OK : B_BAD_VALUE);
	if (error == B_OK) {
		*path = BTestShell::GlobalTestDir();
		path->CharacterEscape(" \t\n!\"'`$&()?*+{}[]<>|", '\\');
		*path += "/";
		*path += testApp;
		#ifdef TEST_R5
			*path += "_r5";
		#endif
	}
	return error;
}

// find_test_app
status_t
find_test_app(const char *testApp, entry_ref *ref)
{
	status_t error = (testApp && ref ? B_OK : B_BAD_VALUE);
	BString path;
	if (error == B_OK)
		error = find_test_app(testApp, &path);
	if (error == B_OK)
		error = get_ref_for_path(path.String(), ref);
	return error;
}