xref: /haiku/src/servers/package/PackageManager.cpp (revision 38c62dfb8b5acffe9373b19e087d037d38a281a5)

/*
 * Copyright 2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "PackageManager.h"

#include <Alert.h>
#include <Notification.h>
#include <package/DownloadFileRequest.h>
#include <package/RefreshRepositoryRequest.h>
#include <package/solver/SolverPackage.h>
#include <package/solver/SolverPackageSpecifierList.h>
#include <package/solver/SolverProblem.h>
#include <package/solver/SolverProblemSolution.h>

#include <package/manager/Exceptions.h>
#include <package/manager/RepositoryBuilder.h>
#include <Server.h>

#include "ProblemWindow.h"
#include "Root.h"
#include "Volume.h"


using BPackageKit::BManager::BPrivate::BAbortedByUserException;
using BPackageKit::BManager::BPrivate::BFatalErrorException;
using BPackageKit::BManager::BPrivate::BRepositoryBuilder;


PackageManager::PackageManager(Root* root, Volume* volume)
	:
	BPackageManager(volume->Location()),
	BPackageManager::UserInteractionHandler(),
	fRoot(root),
	fVolume(volume),
	fContext(*this, *this),
	fSolverPackages(),
	fPackagesAddedByUser(),
	fPackagesRemovedByUser(),
	fProblemWindow(NULL)
{
	fInstallationInterface = this;
	fRequestHandler = this;
	fUserInteractionHandler = this;
}


PackageManager::~PackageManager()
{
	if (fProblemWindow != NULL)
		fProblemWindow->PostMessage(B_QUIT_REQUESTED);
}


void
PackageManager::HandleUserChanges()
{
	const PackageSet& packagesToActivate = fVolume->PackagesToBeActivated();
	const PackageSet& packagesToDeactivate = fVolume->PackagesToBeDeactivated();

	if (packagesToActivate.empty() && packagesToDeactivate.empty())
		return;

	if (packagesToActivate.empty()) {
		// only packages removed -- use uninstall mode
		Init(B_ADD_INSTALLED_REPOSITORIES);

		BSolverPackageSpecifierList packagesToUninstall;
		for (PackageSet::const_iterator it = packagesToDeactivate.begin();
			it != packagesToDeactivate.end(); ++it) {
			BSolverPackage* solverPackage = _SolverPackageFor(*it);
			if (solverPackage == NULL)
				continue;

			if (!packagesToUninstall.AppendSpecifier(solverPackage))
				throw std::bad_alloc();
			fPackagesRemovedByUser.insert(solverPackage);
		}

		if (fPackagesRemovedByUser.empty())
			return;

		Uninstall(packagesToUninstall);
	} else {
		// packages added and (possibly) remove -- manually add/remove those
		// from the repository and use verify mode
		Init(B_ADD_INSTALLED_REPOSITORIES | B_ADD_REMOTE_REPOSITORIES
			| B_REFRESH_REPOSITORIES);

		// disable and remove uninstalled packages
		InstalledRepository& repository = InstallationRepository();
		for (PackageSet::const_iterator it = packagesToDeactivate.begin();
			it != packagesToDeactivate.end(); ++it) {
			BSolverPackage* solverPackage = _SolverPackageFor(*it);
			if (solverPackage == NULL)
				continue;

			repository.DisablePackage(solverPackage);
			if (!repository.PackagesToDeactivate().AddItem(solverPackage))
				throw std::bad_alloc();
			fPackagesRemovedByUser.insert(solverPackage);
		}

		// add new packages
		BRepositoryBuilder repositoryBuilder(repository);
		for (PackageSet::const_iterator it = packagesToActivate.begin();
			it != packagesToActivate.end(); ++it) {
			Package* package = *it;
			BSolverPackage* solverPackage;
			repositoryBuilder.AddPackage(package->Info(), NULL, &solverPackage);
			fSolverPackages[package] = solverPackage;
			if (!repository.PackagesToActivate().AddItem(solverPackage))
				throw std::bad_alloc();
			fPackagesAddedByUser.insert(solverPackage);
		}

		if (fPackagesRemovedByUser.empty() && fPackagesAddedByUser.empty())
			return;

// TODO: When packages are moved out of the packages directory, we can't create
// a complete "old-state" directory.

		VerifyInstallation();
	}
}


void
PackageManager::InitInstalledRepository(InstalledRepository& repository)
{
	const char* name = repository.InitialName();
	BRepositoryBuilder repositoryBuilder(repository, name);

	if (Volume* volume = fRoot->GetVolume(repository.Location())) {
		for (PackageFileNameHashTable::Iterator it
				= volume->PackagesByFileName().GetIterator(); it.HasNext();) {
			Package* package = it.Next();
			if (package->IsActive()) {
				BSolverPackage* solverPackage;
				repositoryBuilder.AddPackage(package->Info(), NULL,
					&solverPackage);
				fSolverPackages[package] = solverPackage;
			}
		}
	}
}


void
PackageManager::ResultComputed(InstalledRepository& repository)
{
	// Normalize the result, i.e. remove the packages added by the user which
	// have been removed again in the problem resolution process, and vice
	// versa.
	if (repository.Location() != fVolume->Location())
		return;

	PackageList& packagesToActivate = repository.PackagesToActivate();
	PackageList& packagesToDeactivate = repository.PackagesToDeactivate();

	for (int32 i = 0; BSolverPackage* package = packagesToDeactivate.ItemAt(i);
		i++) {
		if (fPackagesAddedByUser.erase(package) == 0)
			continue;

		for (SolverPackageMap::iterator it = fSolverPackages.begin();
			it != fSolverPackages.end(); ++it) {
			if (it->second == package) {
				fSolverPackages.erase(it);
				break;
			}
		}

		repository.EnablePackage(package);
		packagesToDeactivate.RemoveItemAt(i--);
		packagesToActivate.RemoveItem(package);
		repository.DeletePackage(package);
	}

	for (int32 i = 0; BSolverPackage* package = packagesToActivate.ItemAt(i);
		i++) {
		if (fPackagesRemovedByUser.erase(package) == 0)
			continue;

		repository.EnablePackage(package);
		packagesToActivate.RemoveItemAt(i--);
		packagesToDeactivate.RemoveItem(package);

		// Note: We keep the package activated, but nonetheless it is gone,
		// since the user has removed it from the packages directory. So unless
		// the user moves it back, we won't find it upon next reboot.
		// TODO: We probable even run into trouble when the user moves in a
		// replacement afterward.
	}
}


status_t
PackageManager::PrepareTransaction(Transaction& transaction)
{
	Volume* volume = fRoot->GetVolume(transaction.Repository().Location());
	if (volume == NULL)
		return B_BAD_VALUE;

	return volume->CreateTransaction(transaction.Repository().Location(),
		transaction.ActivationTransaction(),
		transaction.TransactionDirectory());
}


status_t
PackageManager::CommitTransaction(Transaction& transaction,
	BDaemonClient::BCommitTransactionResult& _result)
{
debug_printf("PackageManager::CommitTransaction()\n");
	Volume* volume = fRoot->GetVolume(transaction.Repository().Location());
	if (volume == NULL)
		return B_BAD_VALUE;

	// Get the packages that have already been added to/removed from the
	// packages directory and thus need to be handled specially by
	// Volume::CommitTransaction().
	PackageSet packagesAlreadyAdded;
	PackageSet packagesAlreadyRemoved;
	if (volume == fVolume) {
		const PackageSet& packagesToActivate = volume->PackagesToBeActivated();
		for (PackageSet::const_iterator it = packagesToActivate.begin();
			it != packagesToActivate.end(); ++it) {
			Package* package = *it;
			if (fPackagesAddedByUser.find(_SolverPackageFor(package))
					!= fPackagesAddedByUser.end()) {
				packagesAlreadyAdded.insert(package);
			}
		}

		const PackageSet& packagesToDeactivate
			= volume->PackagesToBeDeactivated();
		for (PackageSet::const_iterator it = packagesToDeactivate.begin();
			it != packagesToDeactivate.end(); ++it) {
			Package* package = *it;
			if (fPackagesRemovedByUser.find(_SolverPackageFor(package))
					!= fPackagesRemovedByUser.end()) {
				packagesAlreadyRemoved.insert(package);
			}
		}
	}
debug_printf("  activating   %ld (%zu) packages\n", transaction.ActivationTransaction().PackagesToActivate().CountStrings(), packagesAlreadyAdded.size());
debug_printf("  deactivating %ld (%zu) packages\n", transaction.ActivationTransaction().PackagesToDeactivate().CountStrings(), packagesAlreadyRemoved.size());

	volume->CommitTransaction(transaction.ActivationTransaction(),
		packagesAlreadyAdded, packagesAlreadyRemoved, _result);
	return B_OK;
}


status_t
PackageManager::RefreshRepository(const BRepositoryConfig& repoConfig)
{
	return BRefreshRepositoryRequest(fContext, repoConfig).Process();
}


status_t
PackageManager::DownloadPackage(const BString& fileURL,
	const BEntry& targetEntry, const BString& checksum)
{
	return DownloadFileRequest(fContext, fileURL, targetEntry, checksum)
		.Process();
}


void
PackageManager::HandleProblems()
{
	_InitGui();

	if (fProblemWindow == NULL)
		fProblemWindow = new ProblemWindow;

	if (!fProblemWindow->Go(fSolver, fPackagesAddedByUser,
			fPackagesRemovedByUser)) {
		throw BAbortedByUserException();
	}
}


void
PackageManager::ConfirmChanges(bool fromMostSpecific)
{
	// Check whether there are any changes other than those made by the user.
	BString alertText(
		"The following additional package changes have to be made:");
	bool hasOtherChanges = false;
	int32 count = fInstalledRepositories.CountItems();
	if (fromMostSpecific) {
		for (int32 i = count - 1; i >= 0; i--)
			hasOtherChanges
				|= _GetResultText(*fInstalledRepositories.ItemAt(i), alertText);
	} else {
		for (int32 i = 0; i < count; i++)
			hasOtherChanges
				|= _GetResultText(*fInstalledRepositories.ItemAt(i), alertText);
	}

	if (!hasOtherChanges)
		return;

	// show an alert
	_InitGui();
	BAlert* alert = new BAlert("Package changes", alertText,
       "Cancel", "Apply changes");
	alert->SetShortcut(0, B_ESCAPE);
	if (alert->Go() == 0)
		throw BAbortedByUserException();
}


void
PackageManager::Warn(status_t error, const char* format, ...)
{
	va_list args;
	va_start(args, format);
	BString message;
	message.SetToFormatVarArgs(format, args);
	va_end(args);

	if (error != B_OK)
		message << BString().SetToFormat(": %s", strerror(error));

	BNotification notification(B_ERROR_NOTIFICATION);
	notification.SetTitle("Package Daemon");
	notification.SetContent(message);
	notification.Send();
}


void
PackageManager::ProgressStartApplyingChanges(InstalledRepository& repository)
{
}


void
PackageManager::ProgressTransactionCommitted(InstalledRepository& repository,
	const char* transactionDirectoryName)
{
}


void
PackageManager::ProgressApplyingChangesDone(InstalledRepository& repository)
{
}


bool
PackageManager::YesNoDecisionNeeded(const BString& description,
	const BString& question, const BString& yes, const BString& no,
	const BString& defaultChoice)
{
	// ATM we need the BDecisionProvider object for the BContext, but we don't
	// execute any request which actually uses it.
	return false;
}


void
PackageManager::JobFailed(BJob* job)
{
// TODO:...
}


void
PackageManager::JobAborted(BJob* job)
{
// TODO:...
}


bool
PackageManager::_GetResultText(InstalledRepository& repository,
	BString& _text)
{
	if (!repository.HasChanges())
		return false;

	bool hasOtherChanges = false;
	bool isTargetLocation
		= repository.Location() == fVolume->Location();

	BString text = BString().SetToFormat("\n  in %s:",
		repository.Name().String());

	PackageList& packagesToActivate = repository.PackagesToActivate();
	PackageList& packagesToDeactivate = repository.PackagesToDeactivate();

	for (int32 i = 0; BSolverPackage* package = packagesToActivate.ItemAt(i);
		i++) {
		if (isTargetLocation
			&& fPackagesAddedByUser.find(package)
				!= fPackagesAddedByUser.end()) {
			continue;
		}

		text << BString().SetToFormat(
			"\n    install package %s from repository %s\n",
			package->Info().FileName().String(),
			package->Repository()->Name().String());
		hasOtherChanges = true;
	}

	for (int32 i = 0; BSolverPackage* package = packagesToDeactivate.ItemAt(i);
		i++) {
		if (isTargetLocation
			&& fPackagesRemovedByUser.find(package)
				!= fPackagesRemovedByUser.end()) {
			continue;
		}

		text << BString().SetToFormat(
			"\n    uninstall package %s\n", package->VersionedName().String());
		hasOtherChanges = true;
	}

	if (!hasOtherChanges)
		return false;

	_text << text;
	return true;
}


BSolverPackage*
PackageManager::_SolverPackageFor(Package* package) const
{
	SolverPackageMap::const_iterator it = fSolverPackages.find(package);
	return it != fSolverPackages.end() ? it->second : NULL;
}


void
PackageManager::_InitGui()
{
	BServer* server = dynamic_cast<BServer*>(be_app);
	if (server == NULL || server->InitGUIContext() != B_OK)
		throw BFatalErrorException("failed to initialize the GUI");
}