haiku.git

/*
 * Copyright 2013-2020, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ingo Weinhold <ingo_weinhold@gmx.de>
 *		Andrew Lindesay <apl@lindesay.co.nz>
 */


#include <package/manager/RepositoryBuilder.h>

#include <errno.h>
#include <dirent.h>

#include <Entry.h>
#include <package/RepositoryCache.h>
#include <Path.h>

#include <AutoDeleter.h>
#include <AutoDeleterPosix.h>

#include "PackageManagerUtils.h"


namespace BPackageKit {

namespace BManager {

namespace BPrivate {


namespace {


class PackageInfoErrorListener : public BPackageInfo::ParseErrorListener {
public:
	PackageInfoErrorListener(const char* context)
		:
		fContext(context)
	{
	}

	virtual void OnError(const BString& message, int line, int column)
	{
		fErrors << BString().SetToFormat("%s: parse error in line %d:%d: %s\n",
			fContext, line, column, message.String());
	}

	const BString& Errors() const
	{
		return fErrors;
	}

private:
	const char*	fContext;
	BString		fErrors;
};


} // unnamed namespace


BRepositoryBuilder::BRepositoryBuilder(BSolverRepository& repository)
	:
	fRepository(repository),
	fErrorName(repository.Name()),
	fPackagePaths(NULL)
{
}


BRepositoryBuilder::BRepositoryBuilder(BSolverRepository& repository,
	const BString& name, const BString& errorName)
	:
	fRepository(repository),
	fErrorName(errorName.IsEmpty() ? name : errorName),
	fPackagePaths(NULL)
{
	status_t error = fRepository.SetTo(name);
	if (error != B_OK)
		DIE(error, "failed to init %s repository", fErrorName.String());
}


BRepositoryBuilder::BRepositoryBuilder(BSolverRepository& repository,
	const BRepositoryConfig& config)
	:
	fRepository(repository),
	fErrorName(fRepository.Name()),
	fPackagePaths(NULL)
{
	status_t error = fRepository.SetTo(config);
	if (error != B_OK)
		DIE(error, "failed to init %s repository", fErrorName.String());
}


BRepositoryBuilder::BRepositoryBuilder(BSolverRepository& repository,
	const BRepositoryCache& cache, const BString& errorName)
	:
	fRepository(repository),
	fErrorName(errorName.IsEmpty() ? cache.Info().Name() : errorName),
	fPackagePaths(NULL)
{
	status_t error = fRepository.SetTo(cache);
	if (error != B_OK)
		DIE(error, "failed to init %s repository", fErrorName.String());
	fErrorName = fRepository.Name();
}


BRepositoryBuilder&
BRepositoryBuilder::SetPackagePathMap(BPackagePathMap* packagePaths)
{
	fPackagePaths = packagePaths;
	return *this;
}


BRepositoryBuilder&
BRepositoryBuilder::AddPackage(const BPackageInfo& info,
	const char* packageErrorName, BSolverPackage** _package)
{
	status_t error = fRepository.AddPackage(info, _package);
	if (error != B_OK) {
		DIE(error, "failed to add %s to %s repository",
			packageErrorName != NULL
				? packageErrorName
				: (BString("package ") << info.Name()).String(),
			fErrorName.String());
	}
	return *this;
}


BRepositoryBuilder&
BRepositoryBuilder::AddPackage(const char* path, BSolverPackage** _package)
{
	// read a package info from the (HPKG or package info) file
	BPackageInfo packageInfo;

	size_t pathLength = strlen(path);
	status_t error;
	PackageInfoErrorListener errorListener(path);
	BEntry entry(path, true);

	if (!entry.Exists()) {
		DIE_DETAILS(errorListener.Errors(), B_ENTRY_NOT_FOUND,
			"the package data file does not exist at \"%s\"", path);
	}

	struct stat entryStat;
	error = entry.GetStat(&entryStat);

	if (error != B_OK) {
		DIE_DETAILS(errorListener.Errors(), error,
			"failed to access the package data file at \"%s\"", path);
	}

	if (entryStat.st_size == 0) {
		DIE_DETAILS(errorListener.Errors(), B_BAD_DATA,
			"empty package data file at \"%s\"", path);
	}

	if (pathLength > 5 && strcmp(path + pathLength - 5, ".hpkg") == 0) {
		// a package file
		error = packageInfo.ReadFromPackageFile(path);
	} else {
		// a package info file (supposedly)
		error = packageInfo.ReadFromConfigFile(entry, &errorListener);
	}

	if (error != B_OK) {
		DIE_DETAILS(errorListener.Errors(), error,
			"failed to read package data file at \"%s\"", path);
	}

	// add the package
	BSolverPackage* package;
	AddPackage(packageInfo, path, &package);

	// enter the package path in the path map, if given
	if (fPackagePaths != NULL)
		(*fPackagePaths)[package] = path;

	if (_package != NULL)
		*_package = package;

	return *this;
}


BRepositoryBuilder&
BRepositoryBuilder::AddPackages(BPackageInstallationLocation location,
	const char* locationErrorName)
{
	status_t error = fRepository.AddPackages(location);
	if (error != B_OK) {
		DIE(error, "failed to add %s packages to %s repository",
			locationErrorName, fErrorName.String());
	}
	return *this;
}


BRepositoryBuilder&
BRepositoryBuilder::AddPackagesDirectory(const char* path)
{
	// open directory
	DirCloser dir(opendir(path));
	if (!dir.IsSet())
		DIE(errno, "failed to open package directory \"%s\"", path);

	// iterate through directory entries
	while (dirent* entry = readdir(dir.Get())) {
		// skip "." and ".."
		const char* name = entry->d_name;
		if (strcmp(name, ".") == 0 || strcmp(name, "..") == 0)
			continue;

		// stat() the entry and skip any non-file
		BPath entryPath;
		status_t error = entryPath.SetTo(path, name);
		if (error != B_OK)
			DIE(errno, "failed to construct path");

		struct stat st;
		if (stat(entryPath.Path(), &st) != 0)
			DIE(errno, "failed to stat() %s", entryPath.Path());

		if (!S_ISREG(st.st_mode))
			continue;

		AddPackage(entryPath.Path());
	}

	return *this;
}


BRepositoryBuilder&
BRepositoryBuilder::AddToSolver(BSolver* solver, bool isInstalled)
{
	fRepository.SetInstalled(isInstalled);

	status_t error = solver->AddRepository(&fRepository);
	if (error != B_OK) {
		DIE(error, "failed to add %s repository to solver",
			fErrorName.String());
	}
	return *this;
}


}	// namespace BPrivate

}	// namespace BManager

}	// namespace BPackageKit