haiku.git

/*
 * Copyright 2013, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include <errno.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>

#include <package/manager/RepositoryBuilder.h>
#include <package/solver/SolverPackageSpecifier.h>
#include <package/solver/SolverPackageSpecifierList.h>
#include <package/solver/SolverProblem.h>
#include <package/solver/SolverResult.h>

#include <AutoDeleter.h>

#include "Command.h"
#include "pkgman.h"


// TODO: internationalization!


using namespace BPackageKit;
using BManager::BPrivate::BPackagePathMap;
using BManager::BPrivate::BRepositoryBuilder;


static const char* const kShortUsage =
	"  %command% <package> ... <repository> [ <priority> ] ...\n"
	"    Resolves all packages the given packages depend on.\n";

static const char* const kLongUsage =
	"Usage: %program% %command% <package> ... <repository> [ <priority> ] ...\n"
	"Resolves and lists all packages the given packages depend on. Fails, if\n"
	"not all dependencies could be resolved.\n"
	"\n"
	"Options:\n"
	"  --debug <level>\n"
	"    Print debug output. <level> should be between 0 (no debug output,\n"
	"    the default) and 10 (most debug output).\n"
	"\n"
	"Arguments:\n"
	"  <package>\n"
	"    The HPKG or package info file of the package for which the\n"
	"    dependencies shall be resolved. Multiple files can be specified.\n"
	"  <repository>\n"
	"    Path to a directory containing packages from which the package's\n"
	"    dependencies shall be resolved. Multiple directories can be\n"
	"    specified.\n"
	"  <priority>\n"
	"    Can follow a <repository> to specify the priority of that\n"
	"    repository. The default priority is 0.\n"
	"\n";


DEFINE_COMMAND(ResolveDependenciesCommand, "resolve-dependencies", kShortUsage,
	kLongUsage, COMMAND_CATEGORY_OTHER)


static void
check_problems(BSolver* solver, const char* errorContext)
{
	if (solver->HasProblems()) {
		fprintf(stderr,
			"Encountered problems %s:\n", errorContext);

		int32 problemCount = solver->CountProblems();
		for (int32 i = 0; i < problemCount; i++) {
			printf("  %" B_PRId32 ": %s\n", i + 1,
				solver->ProblemAt(i)->ToString().String());
		}
		exit(1);
	}
}


static void
verify_result(const BSolverResult& result,
	const BPackagePathMap& specifiedPackagePaths)
{
	// create the solver
	BSolver* solver;
	status_t error = BSolver::Create(solver);
	if (error != B_OK)
		DIE(error, "failed to create solver");

	// Add an installation repository and add all of the result packages save
	// the specified packages.
	BSolverRepository installation;
	BRepositoryBuilder installationBuilder(installation, "installation");

	for (int32 i = 0; const BSolverResultElement* element = result.ElementAt(i);
			i++) {
		BSolverPackage* package = element->Package();
		if (specifiedPackagePaths.find(package) == specifiedPackagePaths.end())
			installationBuilder.AddPackage(package->Info());
	}
	installationBuilder.AddToSolver(solver, true);

	// resolve
	error = solver->VerifyInstallation();
	if (error != B_OK)
		DIE(error, "failed to verify computed package dependencies");

	check_problems(solver, "verifying computed package dependencies");
}


int
ResolveDependenciesCommand::Execute(int argc, const char* const* argv)
{
	while (true) {
		static struct option sLongOptions[] = {
			{ "debug", required_argument, 0, OPTION_DEBUG },
			{ "help", no_argument, 0, 'h' },
			{ 0, 0, 0, 0 }
		};

		opterr = 0; // don't print errors
		int c = getopt_long(argc, (char**)argv, "h", sLongOptions, NULL);
		if (c == -1)
			break;

		if (fCommonOptions.HandleOption(c))
			continue;

		switch (c) {
			case 'h':
				PrintUsageAndExit(false);
				break;

			default:
				PrintUsageAndExit(true);
				break;
		}
	}

	// The remaining arguments are the package (info) files and the repository
	// directories (at least one), optionally with priorities.
	if (argc < optind + 2)
		PrintUsageAndExit(true);

	// Determine where the package list ends and the repository list starts.
	const char* const* specifiedPackages = argv + optind;
	for (; optind < argc; optind++) {
		const char* path = argv[optind];
		struct stat st;
		if (stat(path, &st) != 0)
			DIE(errno, "failed to stat() \"%s\"", path);

		if (S_ISDIR(st.st_mode))
			break;
	}

	const char* const* repositoryDirectories = argv + optind;
	int repositoryDirectoryCount = argc - optind;
	int specifiedPackageCount = repositoryDirectories - specifiedPackages;

	// create the solver
	BSolver* solver;
	status_t error = BSolver::Create(solver);
	if (error != B_OK)
		DIE(error, "failed to create solver");

	solver->SetDebugLevel(fCommonOptions.DebugLevel());

	// add repositories
	BPackagePathMap packagePaths;
	BObjectList<BSolverRepository, true> repositories(10);
	int32 repositoryIndex = 0;
	for (int i = 0; i < repositoryDirectoryCount; i++, repositoryIndex++) {
		const char* directoryPath = repositoryDirectories[i];

		BSolverRepository* repository = new(std::nothrow) BSolverRepository;
		if (repository == NULL || !repositories.AddItem(repository))
			DIE(B_NO_MEMORY, "failed to create repository");


		if (i + 1 < repositoryDirectoryCount) {
			char* end;
			long priority = strtol(repositoryDirectories[i + 1], &end, 0);
			if (*end == '\0') {
				repository->SetPriority((uint8)priority);
				i++;
			}
		}

		BRepositoryBuilder(*repository,
				BString("repository") << repositoryIndex)
			.SetPackagePathMap(&packagePaths)
			.AddPackagesDirectory(directoryPath)
			.AddToSolver(solver);
	}

	// add a repository with only the specified packages
	BPackagePathMap specifiedPackagePaths;
	BSolverRepository dummyRepository;
	{
		BRepositoryBuilder builder(dummyRepository, "dummy",
				"specified packages");
		builder.SetPackagePathMap(&specifiedPackagePaths);

		for (int i = 0; i < specifiedPackageCount; i++)
			builder.AddPackage(specifiedPackages[i]);

		builder.AddToSolver(solver);
	}

	// resolve
	BSolverPackageSpecifierList packagesToInstall;
	for (BPackagePathMap::const_iterator it = specifiedPackagePaths.begin();
		it != specifiedPackagePaths.end(); ++it) {
		if (!packagesToInstall.AppendSpecifier(it->first))
			DIE(B_NO_MEMORY, "failed to add specified package");
	}

	error = solver->Install(packagesToInstall);
	if (error != B_OK)
		DIE(error, "failed to resolve package dependencies");

	check_problems(solver, "resolving package dependencies");

	BSolverResult result;
	error = solver->GetResult(result);
	if (error != B_OK)
		DIE(error, "failed to resolve package dependencies");

	// Verify that the resolved packages don't depend on the specified package.
	verify_result(result, specifiedPackagePaths);

	// print packages
	for (int32 i = 0; const BSolverResultElement* element = result.ElementAt(i);
			i++) {
		// skip the specified package
		BSolverPackage* package = element->Package();
		if (specifiedPackagePaths.find(package) != specifiedPackagePaths.end())
			continue;

		// resolve and print the path
		BPackagePathMap::const_iterator it = packagePaths.find(package);
		if (it == packagePaths.end()) {
			DIE(B_ERROR, "ugh, no package %p (%s-%s) not in package path map",
				package,  package->Info().Name().String(),
				package->Info().Version().ToString().String());
		}

		printf("%s\n", it->second.String());
	}

	return 0;
}