haiku.git

/*
 * Copyright (c) 2010, Haiku, Inc.
 * Distributed under the terms of the MIT license.
 *
 * Author:
 *		Łukasz 'Sil2100' Zemczak <sil2100@vexillium.org>
 */


#include "PackageInstall.h"

#include "InstalledPackageInfo.h"
#include "PackageItem.h"
#include "PackageView.h"

#include <Alert.h>
#include <Catalog.h>
#include <Locale.h>
#include <stdio.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PackageInstall"


static int32
install_function(void* data)
{
	// TODO: Inform if already one thread is running
	if (data == NULL)
		return -1;

	PackageInstall* install = static_cast<PackageInstall*>(data);
	install->Install();
	return 0;
}


PackageInstall::PackageInstall(PackageView* parent)
	:
	fParent(parent),
	fThreadId(-1),
	fCurrentScript(NULL)
{
}


PackageInstall::~PackageInstall()
{
}


status_t
PackageInstall::Start()
{
	status_t ret = B_OK;

	fIdLocker.Lock();
	if (fThreadId > -1) {
		ret = B_BUSY;
	} else {
		fThreadId = spawn_thread(install_function, "install_package",
			B_NORMAL_PRIORITY, this);
		resume_thread(fThreadId);
	}
	fIdLocker.Unlock();

	return ret;
}


void
PackageInstall::Stop()
{
	// TODO: Argh! No killing of threads!! That leaks resources which they
	// allocated. Rather inform them they need to quit, which they do at the
	// next convenient time, then use wait_for_thread() here.
	fIdLocker.Lock();
	if (fThreadId > -1) {
		kill_thread(fThreadId);
		fThreadId = -1;
	}
	fIdLocker.Unlock();

	fCurrentScriptLocker.Lock();
	if (fCurrentScript != NULL) {
		thread_id id = fCurrentScript->GetThreadId();
		if (id > -1) {
			fCurrentScript->SetThreadId(-1);
			kill_thread(id);
		}
		fCurrentScript = NULL;
	}
	fCurrentScriptLocker.Unlock();
}


void
PackageInstall::Install()
{
	// A message sending wrapper around _Install()
	uint32 code = _Install();

	BMessenger messenger(fParent);
	if (messenger.IsValid()) {
		BMessage message(code);
		messenger.SendMessage(&message);
	}
}


static inline BString
get_item_progress_string(uint32 index, uint32 total) 
{
	BString label(B_TRANSLATE("%index% of %total%"));
	BString indexString;
	indexString << (index + 1);
	BString totalString;
	totalString << total;
	label.ReplaceAll("%index%", indexString);
	label.ReplaceAll("%total%", totalString);
	return label;
}


uint32
PackageInstall::_Install()
{
	PackageInfo* info = fParent->GetPackageInfo();
	pkg_profile* type = static_cast<pkg_profile*>(info->GetProfile(
		fParent->CurrentType()));
	uint32 n = type->items.CountItems();
	uint32 m = info->GetScriptCount();

	PackageStatus* progress = fParent->StatusWindow();
	progress->Reset(n + m + 5);

	progress->StageStep(1, B_TRANSLATE("Preparing package"));

	InstalledPackageInfo packageInfo(info->GetName(), info->GetVersion());

	status_t err = packageInfo.InitCheck();
	if (err == B_OK) {
		// The package is already installed, inform the user
		BAlert* reinstall = new BAlert("reinstall",
			B_TRANSLATE("The given package seems to be already installed on "
				"your system. Would you like to uninstall the existing one "
				"and continue the installation?"),
			B_TRANSLATE("Continue"),
			B_TRANSLATE("Abort"));
		reinstall->SetShortcut(1, B_ESCAPE);

		if (reinstall->Go() == 0) {
			// Uninstall the package
			err = packageInfo.Uninstall();
			if (err != B_OK) {
				fprintf(stderr, "Error uninstalling previously installed "
					"package: %s\n", strerror(err));
				// Ignore error
			}

			err = packageInfo.SetTo(info->GetName(), info->GetVersion(), true);
			if (err != B_OK) {
				fprintf(stderr, "Error marking installation of package: "
					"%s\n", strerror(err));
				return P_MSG_I_ERROR;
			}
		} else {
			// Abort the installation
			return P_MSG_I_ABORT;
		}
	} else if (err == B_ENTRY_NOT_FOUND) {
		err = packageInfo.SetTo(info->GetName(), info->GetVersion(), true);
		if (err != B_OK) {
				fprintf(stderr, "Error marking installation of package: "
					"%s\n", strerror(err));
			return P_MSG_I_ERROR;
		}
	} else if (progress->Stopped()) {
		return P_MSG_I_ABORT;
	} else {
		fprintf(stderr, "returning on error\n");
		return P_MSG_I_ERROR;
	}

	progress->StageStep(1, B_TRANSLATE("Installing files and folders"));

	// Install files and directories

	packageInfo.SetName(info->GetName());
	// TODO: Here's a small problem, since right now it's not quite sure
	//		which description is really used as such. The one displayed on
	//		the installer is mostly package installation description, but
	//		most people use it for describing the application in more detail
	//		then in the short description.
	//		For now, we'll use the short description if possible.
	BString description = info->GetShortDescription();
	if (description.Length() <= 0)
		description = info->GetDescription();
	packageInfo.SetDescription(description.String());
	packageInfo.SetSpaceNeeded(type->space_needed);

	fItemExistsPolicy = P_EXISTS_NONE;

	const char* installPath = fParent->CurrentPath()->Path();
	for (uint32 i = 0; i < n; i++) {
		ItemState state(fItemExistsPolicy);
		PackageItem* item = static_cast<PackageItem*>(type->items.ItemAt(i));

		err = item->DoInstall(installPath, &state);
		if (err == B_FILE_EXISTS) {
			// Writing to path failed because path already exists - ask the user
			// what to do and retry the writing process
			int32 choice = fParent->ItemExists(*item, state.destination,
				fItemExistsPolicy);
			if (choice != P_EXISTS_ABORT) {
				state.policy = choice;
				err = item->DoInstall(installPath, &state);
			}
		}

		if (err != B_OK) {
			fprintf(stderr, "Error '%s' while writing path\n", strerror(err));
			return P_MSG_I_ERROR;
		}

		if (progress->Stopped())
			return P_MSG_I_ABORT;

		// Update progress
		progress->StageStep(1, NULL, get_item_progress_string(i, n).String());

		// Mark installed item in packageInfo
		packageInfo.AddItem(state.destination.Path());
	}

	progress->StageStep(1, B_TRANSLATE("Running post-installation scripts"),
		 "");

	// Run all scripts
	// TODO: Change current working directory to installation location!
	for (uint32 i = 0; i < m; i++) {
		PackageScript* script = info->GetScript(i);

		fCurrentScriptLocker.Lock();
		fCurrentScript = script;

		status_t status = script->DoInstall(installPath);
		if (status != B_OK) {
			fprintf(stderr, "Error while running script: %s\n",
				strerror(status));
			fCurrentScriptLocker.Unlock();
			return P_MSG_I_ERROR;
		}
		fCurrentScriptLocker.Unlock();

		wait_for_thread(script->GetThreadId(), &status);

		fCurrentScriptLocker.Lock();
		script->SetThreadId(-1);
		fCurrentScript = NULL;
		fCurrentScriptLocker.Unlock();

		if (progress->Stopped())
			return P_MSG_I_ABORT;

		progress->StageStep(1, NULL, get_item_progress_string(i, m).String());
	}

	progress->StageStep(1, B_TRANSLATE("Finishing installation"), "");

	err = packageInfo.Save();
	if (err != B_OK)
		return P_MSG_I_ERROR;

	progress->StageStep(1, B_TRANSLATE("Done"));

	// Inform our parent that we finished
	return P_MSG_I_FINISHED;
}