haiku.git

//	LaunchTesterHelper.cpp

#include <stdio.h>
#include <string.h>

#include <Autolock.h>
#include <Entry.h>
#include <List.h>
#include <Message.h>
#include <Messenger.h>
#include <Path.h>

#include "LaunchTesterHelper.h"
#include "RosterTestAppDefs.h"

/////////////////
// LaunchContext

const char *LaunchContext::kStandardArgv[] = {
	"Some", "nice", "arguments"
};
const int32 LaunchContext::kStandardArgc
	= sizeof(kStandardArgv) / sizeof(const char*);

// Message
class LaunchContext::Message {
public:
	BMessage	message;
	bigtime_t	when;
};

// Sleeper
class LaunchContext::Sleeper {
public:
	Sleeper() : fMessageCode(0), fSemaphore(-1) {}

	~Sleeper()
	{
		delete_sem(fSemaphore);
	}

	status_t Init(uint32 messageCode)
	{
		fMessageCode = messageCode;
		fSemaphore = create_sem(0, "sleeper sem");
		return (fSemaphore >= 0 ? B_OK : fSemaphore);
	}

	uint32 MessageCode() const { return fMessageCode; }

	status_t Sleep(bigtime_t timeout = B_INFINITE_TIMEOUT)
	{
		return acquire_sem_etc(fSemaphore, 1, B_RELATIVE_TIMEOUT, timeout);
	}

	status_t WakeUp()
	{
		return release_sem(fSemaphore);
	}

private:
	uint32		fMessageCode;
	sem_id		fSemaphore;
};

// AppInfo
class LaunchContext::AppInfo {
public:
	AppInfo(team_id team)
		: fTeam(team),
		  fMessenger(),
		  fMessages(),
		  fTerminating(false)
	{
	}

	~AppInfo()
	{
		for (int32 i = 0; LaunchContext::Message *message = MessageAt(i); i++)
			delete message;
	}

	team_id Team() const
	{
		return fTeam;
	}

	void SetMessenger(BMessenger messenger)
	{
		fMessenger = messenger;
	}

	BMessenger Messenger() const
	{
		return fMessenger;
	}

	void Terminate()
	{
		if (!fTerminating && fMessenger.IsValid())
		{
			fTerminating = true;
			fMessenger.SendMessage(B_QUIT_REQUESTED);
		}
	}

	void AddMessage(const BMessage &_message)
	{
		LaunchContext::Message *message = new LaunchContext::Message;
		message->message = _message;
		message->when = system_time();
		fMessages.AddItem(message);
		NotifySleepers(_message.what);
	}

	LaunchContext::Message *RemoveMessage(int32 index)
	{
		return (LaunchContext::Message*)fMessages.RemoveItem(index);
	}

	LaunchContext::Message *MessageAt(int32 index) const
	{
		return (LaunchContext::Message*)fMessages.ItemAt(index);
	}

	LaunchContext::Message *FindMessage(uint32 messageCode,
										int32 startIndex = 0) const
	{
		LaunchContext::Message *message = NULL;
		for (int32 i = startIndex; (message = MessageAt(i)) != NULL; i++) {
			if (message->message.what == messageCode)
				break;
		}
		return message;
	}

	void AddSleeper(Sleeper *sleeper)
	{
		fSleepers.AddItem(sleeper);
	}

	void RemoveSleeper(Sleeper *sleeper)
	{
		fSleepers.RemoveItem(sleeper);
	}

	void NotifySleepers(uint32 messageCode)
	{
		for (int32 i = 0;
			 Sleeper *sleeper = (Sleeper*)fSleepers.ItemAt(i);
			 i++) {
			if (sleeper->MessageCode() == messageCode)
				sleeper->WakeUp();
		}
	}

private:
	team_id		fTeam;
	BMessenger	fMessenger;
	BList		fMessages;
	bool		fTerminating;
	BList		fSleepers;
};

// constructor
LaunchContext::LaunchContext()
	: fAppInfos(),
	  fSleepers(),
	  fLock(),
	  fAppThread(B_ERROR),
	  fTerminator(B_ERROR),
	  fTerminating(false)
{
	RosterLaunchApp *app = dynamic_cast<RosterLaunchApp*>(be_app);
	app->SetLaunchContext(this);
	app->Unlock();
	fAppThread = spawn_thread(AppThreadEntry, "app thread", B_NORMAL_PRIORITY,
							  this);
	if (fAppThread >= 0) {
		status_t error = resume_thread(fAppThread);
		if (error != B_OK)
			printf("ERROR: Couldn't resume app thread: %s\n", strerror(error));
	} else
		printf("ERROR: Couldn't spawn app thread: %s\n", strerror(fAppThread));
}

// destructor
LaunchContext::~LaunchContext()
{
	Terminate();
	// cleanup
	for (int32 i = 0; AppInfo *info = AppInfoAt(i); i++)
		delete info;
	for (int32 i = 0;
		 BMessage *message = (BMessage*)fStandardMessages.ItemAt(i);
		 i++) {
		delete message;
	}
}

// ()
status_t
LaunchContext::operator()(LaunchCaller &caller, const char *type,
						  team_id *team)
{
	BMessage message1(MSG_1);
	BMessage message2(MSG_2);
	BMessage message3(MSG_3);
	BList messages;
	messages.AddItem(&message1);
	messages.AddItem(&message2);
	messages.AddItem(&message3);
	return (*this)(caller, type, &messages, kStandardArgc, kStandardArgv,
				   team);
}

// ()
status_t
LaunchContext::operator()(LaunchCaller &caller, const char *type,
						  BList *messages, int32 argc, const char **argv,
						  team_id *team)
{
	BAutolock _lock(fLock);
	status_t result = caller(type, messages, argc, argv, team);
	if (result == B_OK && team)
		CreateAppInfo(*team);
	return result;
}

// HandleMessage
void
LaunchContext::HandleMessage(BMessage *message)
{
//printf("LaunchContext::HandleMessage(%6ld: %.4s)\n",
//message->ReturnAddress().Team(), (char*)&message->what);
//if (message->what == MSG_MESSAGE_RECEIVED) {
//	BMessage sentMessage;
//	message->FindMessage("message", &sentMessage);
//	team_id sender = -1;
//	message->FindInt32("sender", &sender);
//	printf("  <- %6ld: %.4s\n", sender, (char*)&sentMessage.what);
//}

	BAutolock _lock(fLock);
	switch (message->what) {
		case MSG_STARTED:
		case MSG_TERMINATED:
		case MSG_MAIN_ARGS:
		case MSG_ARGV_RECEIVED:
		case MSG_REFS_RECEIVED:
		case MSG_MESSAGE_RECEIVED:
		case MSG_QUIT_REQUESTED:
		case MSG_READY_TO_RUN:
		case MSG_1:
		case MSG_2:
		case MSG_3:
		case MSG_REPLY:
		{
			BMessenger messenger = message->ReturnAddress();
			// add the message to the respective team's message list
			// Note: catch messages that have not been sent by us or the
			// remote team. The R5 registrar seems to send a B_REPLY message
			// sometimes.
			team_id sender = -1;
			bool dontIgnore = false;
			if (message->FindInt32("sender", &sender) != B_OK
				|| sender == be_app->Team()
				|| sender == messenger.Team()
				|| (message->FindBool("don't ignore", &dontIgnore) == B_OK)
					&& dontIgnore) {
				AppInfo *info = CreateAppInfo(messenger);
				info->AddMessage(*message);
				if (fTerminating)
					TerminateApp(info);
			}
			NotifySleepers(message->what);
			break;
		}
		default:
			break;
	}
}

// Terminate
void
LaunchContext::Terminate()
{
	fLock.Lock();
	if (!fTerminating) {
		fTerminating = true;
		// tell all test apps to quit
		for (int32 i = 0; AppInfo *info = AppInfoAt(i); i++)
			TerminateApp(info);
		// start terminator
		fTerminator = spawn_thread(TerminatorEntry, "terminator",
								   B_NORMAL_PRIORITY, this);
		if (fTerminator >= 0) {
			status_t error = resume_thread(fTerminator);
			if (error != B_OK) {
				printf("ERROR: Couldn't resume terminator thread: %s\n",
					   strerror(error));
			}
		} else {
			printf("ERROR: Couldn't spawn terminator thread: %s\n",
				   strerror(fTerminator));
		}
	}
	fLock.Unlock();
	// wait for the app to terminate
	int32 dummy;
	wait_for_thread(fAppThread, &dummy);
	wait_for_thread(fTerminator, &dummy);
}

// TerminateApp
void
LaunchContext::TerminateApp(team_id team, bool wait)
{
	fLock.Lock();
	if (AppInfo *info = AppInfoFor(team))
		TerminateApp(info);
	fLock.Unlock();
	if (wait)
		WaitForMessage(team, MSG_TERMINATED);
}

// TeamAt
team_id
LaunchContext::TeamAt(int32 index) const
{
	BAutolock _lock(fLock);
	team_id team = B_ERROR;
	if (AppInfo *info = AppInfoAt(index))
		team = info->Team();
	return team;
}

// AppMessengerFor
BMessenger
LaunchContext::AppMessengerFor(team_id team) const
{
	BAutolock _lock(fLock);
	BMessenger result;
	if (AppInfoFor(team)) {
		// We need to do some hacking.
		BMessenger messenger;
		struct fake_messenger {
			port_id	fPort;
			int32	fHandlerToken;
			team_id	fTeam;
			int32	extra0;
			int32	extra1;
			bool	fPreferredTarget;
			bool	extra2;
			bool	extra3;
			bool	extra4;
		} &fake = *(fake_messenger*)&messenger;
		status_t error = B_OK;
		fake.fTeam = team;
		// find app looper port
		bool found = false;
		int32 cookie = 0;
		port_info info;
		while (error == B_OK && !found) {
			error = get_next_port_info(fake.fTeam, &cookie, &info);
			found = (error == B_OK
					 && (!strcmp("AppLooperPort", info.name)
					 	 || !strcmp("rAppLooperPort", info.name)));
		}
		// init messenger
		if (error == B_OK) {
			fake.fPort = info.port;
			fake.fHandlerToken = 0;
			fake.fPreferredTarget = true;
		}
		if (error == B_OK)
			result = messenger;
	}
	return result;
}

// NextMessageFrom
BMessage*
LaunchContext::NextMessageFrom(team_id team, int32 &cookie, bigtime_t *time)
{
	BAutolock _lock(fLock);
	BMessage *message = NULL;
	if (AppInfo *info = AppInfoFor(team)) {
		if (Message *contextMessage = info->MessageAt(cookie++))
			message = &contextMessage->message;
	}
	return message;
}

// CheckNextMessage
bool
LaunchContext::CheckNextMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, uint32 what)
{
	BMessage *message = NextMessageFrom(team, cookie);
	return (message && message->what == what);
}

// CheckMainArgsMessage
bool
LaunchContext::CheckMainArgsMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, const entry_ref *appRef,
								bool useRef)
{
	int32 argc = 0;
	const char **argv = NULL;
	if (caller.SupportsArgv()) {
		argc = kStandardArgc;
		argv = kStandardArgv;
	}
	return CheckMainArgsMessage(caller, team, cookie, appRef, argc, argv,
								useRef);
}

// CheckMainArgsMessage
bool
LaunchContext::CheckMainArgsMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, const entry_ref *appRef,
								int32 argc, const char **argv, bool useRef)
{
	useRef &= caller.SupportsArgv() && argv && argc > 0;
	const entry_ref *ref = (useRef ? caller.Ref() : NULL);
	return CheckArgsMessage(caller, team, cookie, appRef, ref, argc, argv,
							MSG_MAIN_ARGS);
}

// CheckArgvMessage
bool
LaunchContext::CheckArgvMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, const entry_ref *appRef,
								bool useRef)
{
	bool result = true;
	if (caller.SupportsArgv()) {
		result = CheckArgvMessage(caller, team, cookie, appRef, kStandardArgc,
								  kStandardArgv, useRef);
	}
	return result;
}

// CheckArgvMessage
bool
LaunchContext::CheckArgvMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, const entry_ref *appRef,
								int32 argc, const char **argv, bool useRef)
{
	const entry_ref *ref = (useRef ? caller.Ref() : NULL);
	return CheckArgvMessage(caller, team, cookie, appRef, ref , argc, argv);
}

// CheckArgvMessage
bool
LaunchContext::CheckArgvMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, const entry_ref *appRef,
								const entry_ref *ref , int32 argc,
								const char **argv)
{
	return CheckArgsMessage(caller, team, cookie, appRef, ref, argc, argv,
							MSG_ARGV_RECEIVED);
}

// CheckArgsMessage
bool
LaunchContext::CheckArgsMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, const entry_ref *appRef,
								const entry_ref *ref , int32 argc,
								const char **argv, uint32 messageCode)
{
	BMessage *message = NextMessageFrom(team, cookie);
	bool result = (message && message->what == messageCode);
	int32 additionalRef = (ref ? 1 : 0);
	// check argc
	int32 foundArgc = -1;
	if (result) {
		result = (message->FindInt32("argc", &foundArgc) == B_OK
				  && foundArgc == argc + 1 + additionalRef);
if (!result)
printf("argc differ: %ld vs %ld + 1 + %ld\n", foundArgc, argc, additionalRef);
	}
	// check argv[0] (the app file name)
	if (result) {
		BPath path;
		const char *arg = NULL;
		result = (path.SetTo(appRef) == B_OK
				  && message->FindString("argv", 0, &arg) == B_OK
				  && path == arg);
if (!result)
printf("app paths differ: `%s' vs `%s'\n", arg, path.Path());
	}
	// check remaining argv
	for (int32 i = 1; result && i < argc; i++) {
		const char *arg = NULL;
		result = (message->FindString("argv", i, &arg) == B_OK
				  && !strcmp(arg, argv[i - 1]));
if (!result)
printf("arg[%ld] differ: `%s' vs `%s'\n", i, arg, argv[i - 1]);
	}
	// check additional ref
	if (result && additionalRef) {
		BPath path;
		const char *arg = NULL;
		result = (path.SetTo(ref) == B_OK
				  && message->FindString("argv", argc + 1, &arg) == B_OK
				  && path == arg);
if (!result)
printf("document paths differ: `%s' vs `%s'\n", arg, path.Path());
	}
	return result;
}

// CheckMessageMessages
bool
LaunchContext::CheckMessageMessages(LaunchCaller &caller, team_id team,
									int32 &cookie)
{
	BAutolock _lock(fLock);
	bool result = true;
	for (int32 i = 0; i < 3; i++)
		result &= CheckMessageMessage(caller, team, cookie, i);
	return result;
}

// CheckMessageMessage
bool
LaunchContext::CheckMessageMessage(LaunchCaller &caller, team_id team,
								   int32 &cookie, int32 index)
{
	bool result = true;
	if (caller.SupportsMessages() > index && index < 3) {
		uint32 commands[] = { MSG_1, MSG_2, MSG_3 };
		BMessage message(commands[index]);
		result = CheckMessageMessage(caller, team, cookie, &message);
	}
	return result;
}

// CheckMessageMessage
bool
LaunchContext::CheckMessageMessage(LaunchCaller &caller, team_id team,
								   int32 &cookie,
								   const BMessage *expectedMessage)
{
	BMessage *message = NextMessageFrom(team, cookie);
	bool result = (message && message->what == MSG_MESSAGE_RECEIVED);
	if (result) {
		BMessage sentMessage;
		result = (message->FindMessage("message", &sentMessage) == B_OK
				  && sentMessage.what == expectedMessage->what);
	}
	return result;
}

// CheckRefsMessage
bool
LaunchContext::CheckRefsMessage(LaunchCaller &caller, team_id team,
								int32 &cookie)
{
	bool result = true;
	if (caller.SupportsRefs())
		result = CheckRefsMessage(caller, team, cookie, caller.Ref());
	return result;
}

// CheckRefsMessage
bool
LaunchContext::CheckRefsMessage(LaunchCaller &caller, team_id team,
								int32 &cookie, const entry_ref *refs,
								int32 count)
{
	BMessage *message = NextMessageFrom(team, cookie);
	bool result = (message && message->what == MSG_REFS_RECEIVED);
	if (result) {
		entry_ref ref;
		for (int32 i = 0; result && i < count; i++) {
			result = (message->FindRef("refs", i, &ref) == B_OK
					  && ref == refs[i]);
		}
	}
	return result;
}

// WaitForMessage
bool
LaunchContext::WaitForMessage(uint32 messageCode, bool fromNow,
							  bigtime_t timeout)
{
	status_t error = B_ERROR;
	fLock.Lock();
	error = B_OK;
	if (fromNow || !FindMessage(messageCode)) {
		// add sleeper
		Sleeper *sleeper = new Sleeper;
		error = sleeper->Init(messageCode);
		if (error == B_OK) {
			AddSleeper(sleeper);
			fLock.Unlock();
			// sleep
			error = sleeper->Sleep(timeout);
			fLock.Lock();
			// remove sleeper
			RemoveSleeper(sleeper);
			delete sleeper;
		}
	}
	fLock.Unlock();
	return (error == B_OK);
}

// WaitForMessage
bool
LaunchContext::WaitForMessage(team_id team, uint32 messageCode, bool fromNow,
							  bigtime_t timeout, int32 startIndex)
{
	status_t error = B_ERROR;
	fLock.Lock();
	if (AppInfo *info = AppInfoFor(team)) {
		error = B_OK;
		if (fromNow || !info->FindMessage(messageCode, startIndex)) {
			// add sleeper
			Sleeper *sleeper = new Sleeper;
			error = sleeper->Init(messageCode);
			if (error == B_OK) {
				info->AddSleeper(sleeper);
				fLock.Unlock();
				// sleep
				error = sleeper->Sleep(timeout);
				fLock.Lock();
				// remove sleeper
				info->RemoveSleeper(sleeper);
				delete sleeper;
			}
		}
	}
	fLock.Unlock();
	return (error == B_OK);
}

// StandardMessages
BList*
LaunchContext::StandardMessages()
{
	if (fStandardMessages.IsEmpty()) {
		fStandardMessages.AddItem(new BMessage(MSG_1));
		fStandardMessages.AddItem(new BMessage(MSG_2));
		fStandardMessages.AddItem(new BMessage(MSG_3));
	}
	return &fStandardMessages;
}

// AppInfoAt
LaunchContext::AppInfo*
LaunchContext::AppInfoAt(int32 index) const
{
	return (AppInfo*)fAppInfos.ItemAt(index);
}

// AppInfoFor
LaunchContext::AppInfo*
LaunchContext::AppInfoFor(team_id team) const
{
	for (int32 i = 0; AppInfo *info = AppInfoAt(i); i++) {
		if (info->Team() == team)
			return info;
	}
	return NULL;
}

// CreateAppInfo
LaunchContext::AppInfo*
LaunchContext::CreateAppInfo(BMessenger messenger)
{
	return CreateAppInfo(messenger.Team(), &messenger);
}

// CreateAppInfo
LaunchContext::AppInfo*
LaunchContext::CreateAppInfo(team_id team, const BMessenger *messenger)
{
	AppInfo *info = AppInfoFor(team);
	if (!info) {
		info = new AppInfo(team);
		fAppInfos.AddItem(info);
	}
	if (messenger && !info->Messenger().IsValid())
		info->SetMessenger(*messenger);
	return info;
}

// TerminateApp
void
LaunchContext::TerminateApp(AppInfo *info)
{
	if (info)
		info->Terminate();
}

// Terminator
int32
LaunchContext::Terminator()
{
	bool allGone = false;
	while (!allGone) {
		allGone = true;
		fLock.Lock();
		for (int32 i = 0; AppInfo *info = AppInfoAt(i); i++) {
			team_info teamInfo;
			allGone &= (get_team_info(info->Team(), &teamInfo) != B_OK);
		}
		fLock.Unlock();
		if (!allGone)
			snooze(10000);
	}
	be_app->PostMessage(B_QUIT_REQUESTED, be_app);
	return 0;
}

// AppThreadEntry
int32
LaunchContext::AppThreadEntry(void *)
{
	be_app->Lock();
	be_app->Run();
	return 0;
}

// TerminatorEntry
int32
LaunchContext::TerminatorEntry(void *data)
{
	return ((LaunchContext*)data)->Terminator();
}

// FindMessage
LaunchContext::Message*
LaunchContext::FindMessage(uint32 messageCode)
{
	BAutolock _lock(fLock);
	Message *message = NULL;
	AppInfo *info = NULL;
	for (int32 i = 0; !message && (info = AppInfoAt(i)) != NULL; i++)
		message = info->FindMessage(messageCode);
	return message;
}

// AddSleeper
void
LaunchContext::AddSleeper(Sleeper *sleeper)
{
	fSleepers.AddItem(sleeper);
}

// RemoveSleeper
void
LaunchContext::RemoveSleeper(Sleeper *sleeper)
{
	fSleepers.RemoveItem(sleeper);
}

// NotifySleepers
void
LaunchContext::NotifySleepers(uint32 messageCode)
{
	for (int32 i = 0; Sleeper *sleeper = (Sleeper*)fSleepers.ItemAt(i); i++) {
		if (sleeper->MessageCode() == messageCode)
			sleeper->WakeUp();
	}
}


///////////////////
// RosterLaunchApp

// constructor
RosterLaunchApp::RosterLaunchApp(const char *signature)
	: BApplication(signature),
	  fLaunchContext(NULL),
	  fHandler(NULL)
{
}

// destructor
RosterLaunchApp::~RosterLaunchApp()
{
	SetHandler(NULL);
}

// MessageReceived
void
RosterLaunchApp::MessageReceived(BMessage *message)
{
	if (fLaunchContext)
		fLaunchContext->HandleMessage(message);
}

// SetLaunchContext
void
RosterLaunchApp::SetLaunchContext(LaunchContext *context)
{
	fLaunchContext = context;
}

// GetLaunchContext
LaunchContext *
RosterLaunchApp::GetLaunchContext() const
{
	return fLaunchContext;
}

// SetHandler
void
RosterLaunchApp::SetHandler(BHandler *handler)
{
	Lock();
	if (fHandler) {
		RemoveHandler(fHandler);
		delete fHandler;
		fHandler = NULL;
	}
	if (handler) {
		fHandler = handler;
		AddHandler(handler);
	}
	Unlock();
}


//////////////////////////
// RosterBroadcastHandler

// constructor
RosterBroadcastHandler::RosterBroadcastHandler()
{
}

// MessageReceived
void
RosterBroadcastHandler::MessageReceived(BMessage *message)
{
	RosterLaunchApp *app = dynamic_cast<RosterLaunchApp*>(be_app);
	if (LaunchContext *launchContext = app->GetLaunchContext()) {
		message->AddInt32("original what", (int32)message->what);
		message->what = MSG_REPLY;
		launchContext->HandleMessage(message);
	}
}