diff --git a/ahriman-core/src/ahriman/application/application/application.py b/ahriman-core/src/ahriman/application/application/application.py index cdc5ad98..01bdaaf1 100644 --- a/ahriman-core/src/ahriman/application/application/application.py +++ b/ahriman-core/src/ahriman/application/application/application.py @@ -22,7 +22,7 @@ from collections.abc import Callable, Iterable from ahriman.application.application.application_packages import ApplicationPackages from ahriman.application.application.application_repository import ApplicationRepository from ahriman.core.formatters import UpdatePrinter -from ahriman.core.tree import Tree +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.package import Package from ahriman.models.result import Result @@ -95,43 +95,39 @@ class Application(ApplicationPackages, ApplicationRepository): """ self.repository.triggers.on_stop() - def print_updates(self, packages: list[Package], *, log_fn: Callable[[str], None]) -> None: + def print_updates(self, plan: BuildPlan, log_fn: Callable[[str], None], *, bump_pkgrel: bool = True) -> None: """ - print list of packages to be built. This method will build dependency tree and print updates accordingly + print packages and their reasons, grouped by dependency step Args: - packages(list[Package]): package list to be printed + plan(BuildPlan): packages and selection reasons to be printed log_fn(Callable[[str], None]): logger function to log updates + bump_pkgrel(bool, optional): whether duplicate releases are expected to increment """ local_versions = {package.base: package.version for package in self.repository.packages()} + UpdatePrinter(plan, local_versions, bump_pkgrel=bump_pkgrel)(verbose=True, log_fn=log_fn) - tree = Tree.resolve(packages) - for level in tree: - for package in level: - UpdatePrinter(package, local_versions.get(package.base))(verbose=True, log_fn=log_fn, separator=" -> ") - - def with_dependencies(self, packages: list[Package], *, process_dependencies: bool) -> list[Package]: + def with_dependencies(self, plan: BuildPlan, *, process_dependencies: bool) -> BuildPlan: """ - add missing dependencies to list of packages. This will extract known packages, check dependencies of - the supplied packages and add packages which are not presented in the list of known packages. + add missing dependencies to a build plan and record which packages require them Args: - packages(list[Package]): list of source packages of which dependencies have to be processed + plan(BuildPlan): selected packages and their reasons process_dependencies(bool): if set to ``False``, dependencies will not be processed Returns: - list[Package]: updated packages list. Packager for dependencies will be copied from the original package + BuildPlan: selected packages and their dependencies Examples: In the most cases, in order to avoid build failure, it is required to add missing packages, which can be done by calling:: >>> application = ... - >>> packages = application.with_dependencies(packages, process_dependencies=True) - >>> application.print_updates(packages, log_fn=print) + >>> plan = application.with_dependencies(plan, process_dependencies=True) + >>> application.update(plan) """ - if not process_dependencies or not packages: - return packages + if not process_dependencies or not plan: + return plan def missing_dependencies(sources: Iterable[Package]) -> dict[str, str | None]: # append list of known packages with packages which are in current sources @@ -148,7 +144,7 @@ class Application(ApplicationPackages, ApplicationRepository): if dependency not in satisfied_packages } - def new_packages(root: Package) -> dict[str, Package]: + def new_packages(root: Package) -> list[Package]: portion = {root.base: root} while missing := missing_dependencies(portion.values()): for package_name, packager in missing.items(): @@ -162,15 +158,17 @@ class Application(ApplicationPackages, ApplicationRepository): # register package in the database self.reporter.set_unknown(leaf) - return portion + return [leaf for package_name, leaf in portion.items() if package_name != root.base] known_packages = self._known_packages() - with_dependencies: dict[str, Package] = {} - for package in packages: + for package in plan: with self.in_package_context(package.base, package.version): # use the same context for the logger try: - with_dependencies |= new_packages(package) + packages = new_packages(package) except Exception: self.logger.exception("could not process dependencies of %s, skip the package", package.base) + continue - return list(with_dependencies.values()) + plan.update(packages, BuildPlanReason.RequiredBy, package.base) + + return plan diff --git a/ahriman-core/src/ahriman/application/application/application_repository.py b/ahriman-core/src/ahriman/application/application/application_repository.py index 2c051834..ffbd6903 100644 --- a/ahriman-core/src/ahriman/application/application/application_repository.py +++ b/ahriman-core/src/ahriman/application/application/application_repository.py @@ -23,6 +23,7 @@ from ahriman.application.application.application_properties import ApplicationPr from ahriman.application.application.workers import Updater from ahriman.core.build_tools.sources import Sources from ahriman.core.exceptions import UnknownPackageError +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.package import Package from ahriman.models.packagers import Packagers from ahriman.models.result import Result @@ -182,7 +183,7 @@ class ApplicationRepository(ApplicationProperties): return result def updates(self, filter_packages: Iterable[str], *, - aur: bool, local: bool, manual: bool, vcs: bool, check_files: bool) -> list[Package]: + aur: bool, local: bool, manual: bool, vcs: bool, check_files: bool) -> BuildPlan: """ get list of packages to run update process @@ -193,25 +194,21 @@ class ApplicationRepository(ApplicationProperties): manual(bool): include or exclude manual updates vcs(bool): enable or disable checking of VCS packages check_files(bool): check for broken dependencies - Returns: - list[Package]: list of out-of-dated packages + BuildPlan: selected packages and their reasons """ - updates = {} + plan = BuildPlan() # always add already built packages, because they will be always added - updates.update({ - package.base: package - for package in self.repository.load_archives(self.repository.packages_built()) - }) + plan.update(self.repository.load_archives(self.repository.packages_built()), BuildPlanReason.PreBuilt) if aur: - updates.update({package.base: package for package in self.repository.updates_aur(filter_packages, vcs=vcs)}) + plan.update(self.repository.updates_aur(filter_packages, vcs=vcs), BuildPlanReason.RegularUpdate) if local: - updates.update({package.base: package for package in self.repository.updates_local(vcs=vcs)}) + plan.update(self.repository.updates_local(vcs=vcs), BuildPlanReason.LocalSourceUpdate) if manual: - updates.update({package.base: package for package in self.repository.updates_manual()}) + plan.update(self.repository.updates_manual(), BuildPlanReason.QueuedRequest) if check_files: - updates.update({package.base: package for package in self.repository.updates_dependencies(filter_packages)}) + plan.update(self.repository.updates_dependencies(filter_packages), BuildPlanReason.BrokenImplicitDependency) - return [package for _, package in sorted(updates.items())] + return plan diff --git a/ahriman-core/src/ahriman/application/handlers/rebuild.py b/ahriman-core/src/ahriman/application/handlers/rebuild.py index c325550e..90eaf67d 100644 --- a/ahriman-core/src/ahriman/application/handlers/rebuild.py +++ b/ahriman-core/src/ahriman/application/handlers/rebuild.py @@ -21,8 +21,10 @@ import argparse from ahriman.application.application import Application from ahriman.application.handlers.handler import Handler, SubParserAction +from ahriman.application.handlers.update import Update from ahriman.core.configuration import Configuration from ahriman.core.utils import extract_user +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.build_status import BuildStatusEnum from ahriman.models.package import Package from ahriman.models.packagers import Packagers @@ -52,12 +54,14 @@ class Rebuild(Handler): packages = Rebuild.extract_packages(application, args.status, from_database=args.from_database) packages = application.repository.packages_depend_on(packages, args.depends_on) - Rebuild.check_status(args.exit_code, packages) + plan = BuildPlan().update(packages, BuildPlanReason.Rebuild) + application.print_updates(plan, Update.log_fn(application, dry_run=args.dry_run), bump_pkgrel=args.increment) + if args.dry_run: - application.print_updates(packages, log_fn=print) + Rebuild.check_status(args.exit_code, plan) return - result = application.update(packages, Packagers(args.username), bump_pkgrel=args.increment) + result = application.update(plan, Packagers(args.username), bump_pkgrel=args.increment) Rebuild.check_status(args.exit_code, not result.is_empty) @staticmethod diff --git a/ahriman-core/src/ahriman/application/handlers/service_updates.py b/ahriman-core/src/ahriman/application/handlers/service_updates.py index 9426fe51..b1ce807e 100644 --- a/ahriman-core/src/ahriman/application/handlers/service_updates.py +++ b/ahriman-core/src/ahriman/application/handlers/service_updates.py @@ -23,6 +23,7 @@ from ahriman import __version__ from ahriman.application.handlers.handler import Handler, SubParserAction from ahriman.core.configuration import Configuration from ahriman.core.formatters import UpdatePrinter +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.package import Package from ahriman.models.repository_id import RepositoryId @@ -56,7 +57,8 @@ class ServiceUpdates(Handler): if same_version: return - UpdatePrinter(remote, local_version)(verbose=True, separator=" -> ") + plan = BuildPlan().update([remote], BuildPlanReason.RegularUpdate) + UpdatePrinter(plan, {remote.base: local_version})(verbose=True) ServiceUpdates.check_status(args.exit_code, same_version) @staticmethod diff --git a/ahriman-core/src/ahriman/application/handlers/update.py b/ahriman-core/src/ahriman/application/handlers/update.py index 5fa10f25..bd949f63 100644 --- a/ahriman-core/src/ahriman/application/handlers/update.py +++ b/ahriman-core/src/ahriman/application/handlers/update.py @@ -147,20 +147,19 @@ class Update(Handler): application(Application): application instance args(argparse.Namespace): command line args """ - packages = application.updates(args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, - check_files=args.check_files) + plan = application.updates(args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, + check_files=args.check_files) + plan = application.with_dependencies(plan, process_dependencies=args.dependencies) if args.changes: # generate changes if requested - application.changes(packages) + application.changes(plan) + application.print_updates(plan, Update.log_fn(application, dry_run=args.dry_run), bump_pkgrel=args.increment) if args.dry_run: # exit from application if no build requested - Update.check_status(args.exit_code, packages) # status code check + Update.check_status(args.exit_code, plan) # status code check return - packages = application.with_dependencies(packages, process_dependencies=args.dependencies) - packagers = Packagers(args.username, {package.base: package.packager for package in packages}) - - application.print_updates(packages, log_fn=application.logger.info) - result = application.update(packages, packagers, bump_pkgrel=args.increment) + packagers = Packagers(args.username, {package.base: package.packager for package in plan}) + result = application.update(plan, packagers, bump_pkgrel=args.increment) Update.check_status(args.exit_code, not result.is_empty) arguments = [ diff --git a/ahriman-core/src/ahriman/core/formatters/printer.py b/ahriman-core/src/ahriman/core/formatters/printer.py index 4fd4dfa9..639ce363 100644 --- a/ahriman-core/src/ahriman/core/formatters/printer.py +++ b/ahriman-core/src/ahriman/core/formatters/printer.py @@ -46,7 +46,7 @@ class Printer: if not verbose and not prop.is_required: continue indent = "\t" * prop.indent - log_fn(f"{indent}{prop.name}{separator}{prop.value}") + log_fn(f"{indent}{prop.name}{separator if prop.separator is None else prop.separator}{prop.value}") def properties(self) -> list[Property]: """ diff --git a/ahriman-core/src/ahriman/core/formatters/update_printer.py b/ahriman-core/src/ahriman/core/formatters/update_printer.py index fdaf57ba..0bf48635 100644 --- a/ahriman-core/src/ahriman/core/formatters/update_printer.py +++ b/ahriman-core/src/ahriman/core/formatters/update_printer.py @@ -17,30 +17,38 @@ # You should have received a copy of the GNU General Public License # along with this program. If not, see . # +from collections.abc import Iterator + from ahriman.core.formatters.string_printer import StringPrinter +from ahriman.core.tree import Tree from ahriman.core.utils import full_version, parse_version +from ahriman.models.build_plan import BuildPlan from ahriman.models.package import Package from ahriman.models.property import Property class UpdatePrinter(StringPrinter): """ - print content of the package update + print content of the packages update Attributes: - package(Package): remote (new) package object - local_version(str | None): local version of the package if any + plan(BuildPlan): plan to display + local_versions(dict[str, str]): published package versions indexed by base + bump_pkgrel(bool): whether duplicate package releases are expected to increment """ - def __init__(self, remote: Package, local_version: str | None) -> None: + def __init__(self, plan: BuildPlan, local_versions: dict[str, str], *, bump_pkgrel: bool = True) -> None: """ Args: - remote(Package): remote (new) package object - local_version(str | None): local version of the package if any + plan(BuildPlan): plan to display + local_versions(dict[str, str]): published package versions indexed by base + bump_pkgrel(bool, optional): whether duplicate package releases are expected to increment + (Default value = True) """ - StringPrinter.__init__(self, remote.base) - self.package = remote - self.local_version = local_version + StringPrinter.__init__(self, "Build plan" if plan else "No packages selected") + self.plan = plan + self.local_versions = local_versions + self.bump_pkgrel = bump_pkgrel def properties(self) -> list[Property]: """ @@ -49,9 +57,48 @@ class UpdatePrinter(StringPrinter): Returns: list[Property]: list of content properties """ - if (pkgrel := self.package.next_pkgrel(self.local_version)) is not None: - epoch, pkgver, _ = parse_version(self.package.version) + return [ + prop + for level in Tree.resolve(self.plan) + for package in level + for prop in self.properties_package(package) + ] + + def properties_package(self, package: Package) -> Iterator[Property]: + """ + generate list of properties for the specific package + + Args: + package(Package): package object + + Yields: + Property: list of properties belonging to the package + """ + # package header + yield Property(package.base, "", is_required=True) + + # set version update message + local_version, remote_version = self.versions(package) + yield Property(local_version, remote_version, is_required=True, indent=2, separator=" -> ") + + # set reason + item = self.plan.item(package.base) + reason = item.reason.value if item.requester is None else f"{item.reason} {item.requester}" + yield Property("Reason", reason, indent=2) + + def versions(self, package: Package) -> tuple[str, str]: + """ + generate version property + + Returns: + tuple[str, str]: extract current and updated versions for the package + """ + local_version = self.local_versions.get(package.base) + + if self.bump_pkgrel and (pkgrel := package.next_pkgrel(local_version)) is not None: + epoch, pkgver, _ = parse_version(package.version) effective_new_version = full_version(epoch, pkgver, pkgrel) else: - effective_new_version = self.package.version - return [Property(self.local_version or "N/A", effective_new_version, is_required=True)] + effective_new_version = package.version + + return local_version or "N/A", effective_new_version diff --git a/ahriman-core/src/ahriman/core/repository/update_handler.py b/ahriman-core/src/ahriman/core/repository/update_handler.py index dbe42575..620b20f7 100644 --- a/ahriman-core/src/ahriman/core/repository/update_handler.py +++ b/ahriman-core/src/ahriman/core/repository/update_handler.py @@ -188,6 +188,7 @@ class UpdateHandler(PackageInfo, Cleaner): self.reporter.set_pending(local.base) self.event(local.base, EventType.PackageOutdated, "Locally pulled sources are outdated") result.append(remote) + except Exception: self.logger.exception("could not process package at %s", cache_dir) diff --git a/ahriman-core/src/ahriman/models/build_plan.py b/ahriman-core/src/ahriman/models/build_plan.py new file mode 100644 index 00000000..1b904bba --- /dev/null +++ b/ahriman-core/src/ahriman/models/build_plan.py @@ -0,0 +1,183 @@ +# +# Copyright (c) 2021-2026 ahriman team. +# +# This file is part of ahriman +# (see https://github.com/arcan1s/ahriman). +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# +from collections.abc import Iterable, Iterator +from dataclasses import dataclass +from enum import StrEnum +from typing import Any, Self + +from ahriman.models.package import Package + + +class BuildPlanReason(StrEnum): + """ + reason why package was selected for a build plan + + Attributes: + BrokenImplicitDependency(BuildPlanReason): package has a broken implicit dependency + LocalSourceUpdate(BuildPlanReason): locally sourced package has an update + PreBuilt(BuildPlanReason): package has already been built + QueuedRequest(BuildPlanReason): package was manually queued + Rebuild(BuildPlanReason): package was selected for rebuild + RegularUpdate(BuildPlanReason): package has an AUR update + RequiredBy(BuildPlanReason): package is required by another selected package + """ + + BrokenImplicitDependency = "broken implicit dependency" + LocalSourceUpdate = "local source update" + PreBuilt = "pre-built" + QueuedRequest = "queued request" + Rebuild = "rebuild" + RegularUpdate = "regular update" + RequiredBy = "required by" + + +@dataclass(frozen=True) +class BuildPlanItem: + """ + one package and the reason it appears in a build plan + + Attributes: + package(Package): package selected for the plan + reason(BuildPlanReason): why the package was selected + requester(str | None): package that requires this package + """ + + package: Package + reason: BuildPlanReason + requester: str | None = None + + +class BuildPlan(Iterable[Package]): + """ + in-memory preview of the packages selected for a build operation + """ + + def __init__(self) -> None: + """ + initialize an empty build plan + """ + self._items: dict[str, BuildPlanItem] = {} + + @property + def items(self) -> list[BuildPlanItem]: + """ + get plan items in stable package-base order + + Returns: + list[BuildPlanItem]: selected plan items + """ + return [self._items[base] for base in sorted(self._items)] + + @property + def packages(self) -> list[Package]: + """ + get packages in stable package-base order + + Returns: + list[Package]: selected packages + """ + return [item.package for item in self.items] + + def add(self, package: Package, reason: BuildPlanReason, requester: str | None = None) -> BuildPlanItem: + """ + add or update a package in the plan + + Args: + package(Package): package selected for the plan + reason(BuildPlanReason): reason for selecting it + requester(str | None, optional): package requiring this dependency (Default value = None) + + Returns: + BuildPlanItem: plan item for the package + """ + item = self._items[package.base] = BuildPlanItem(package, reason, requester) + return item + + def item(self, package_base: str) -> BuildPlanItem: + """ + get a plan item by package base + + Args: + package_base(str): package base to look up + + Returns: + BuildPlanItem: matching item + """ + return self._items[package_base] + + def update(self, packages: list[Package], reason: BuildPlanReason, requester: str | None = None) -> Self: + """ + bulk update packages with the same reason + + Args: + packages(list[Package]): list of new packages to be added + reason(BuildPlanReason): reason for selecting them + requester(str | None, optional): package requiring these dependencies (Default value = None) + + Returns: + Self: updated plan instance + """ + for package in packages: + self.add(package, reason, requester) + return self + + def __contains__(self, item: Package) -> bool: + """ + check whether plan holds a package or not + + Args: + item(Package): package to lookup + + Returns: + bool: ``True`` in case if the package is already in the plan and ``False`` otherwise + """ + return item.base in self._items + + def __eq__(self, other: Any) -> bool: + """ + check if other is the same object + + Args: + other(Any): other object instance + + Returns: + bool: ``True`` if the other object is the same and ``False`` otherwise + """ + if not isinstance(other, BuildPlan): + return False + return self.items == other.items + + def __iter__(self) -> Iterator[Package]: + """ + iterate over selected packages in stable package-base order + + Returns: + Package: selected package + """ + return iter(self.packages) + + def __len__(self) -> int: + """ + get number of selected packages + + Returns: + int: number of selected packages + """ + return len(self._items) diff --git a/ahriman-core/src/ahriman/models/property.py b/ahriman-core/src/ahriman/models/property.py index 5f3b536f..7bbdb8dc 100644 --- a/ahriman-core/src/ahriman/models/property.py +++ b/ahriman-core/src/ahriman/models/property.py @@ -31,9 +31,11 @@ class Property: value(Any): property value is_required(bool): if set to ``True`` then this property is required indent(int): property indentation level + separator(str | None): optional override for separator """ name: str value: Any is_required: bool = field(default=False, kw_only=True) indent: int = 1 + separator: str | None = None diff --git a/ahriman-core/tests/ahriman/application/application/test_application.py b/ahriman-core/tests/ahriman/application/application/test_application.py index 5df929c4..7c07e8f7 100644 --- a/ahriman-core/tests/ahriman/application/application/test_application.py +++ b/ahriman-core/tests/ahriman/application/application/test_application.py @@ -4,7 +4,7 @@ from typing import Any from unittest.mock import MagicMock, call as MockCall from ahriman.application.application import Application -from ahriman.core.tree import Leaf, Tree +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.package import Package from ahriman.models.result import Result @@ -54,13 +54,11 @@ def test_print_updates(application: Application, package_ahriman: Package, mocke """ must print updates """ - tree = Tree([Leaf(package_ahriman)]) mocker.patch("ahriman.core.repository.repository.Repository.packages", return_value=[package_ahriman]) - mocker.patch("ahriman.core.tree.Tree.resolve", return_value=tree.levels()) print_mock = mocker.patch("ahriman.core.formatters.Printer.print") - application.print_updates([package_ahriman], log_fn=print) - print_mock.assert_called_once_with(verbose=True, log_fn=print, separator=" -> ") + application.print_updates(BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate), log_fn=print) + print_mock.assert_called_once_with(verbose=True, log_fn=print, separator=": ") def test_with_dependencies(application: Application, package_ahriman: Package, package_python_schedule: Package, @@ -99,8 +97,11 @@ def test_with_dependencies(application: Application, package_ahriman: Package, p return_value={"devtools", "python-build", "python-pytest"}) status_client_mock = mocker.patch("ahriman.core.status.Client.set_unknown") - result = application.with_dependencies([package_ahriman], process_dependencies=True) + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + result = application.with_dependencies(plan, process_dependencies=True) assert {package.base: package for package in result} == packages + assert result.item(package_ahriman.base).requester is None + assert result.item(package_python_schedule.base).requester == package_ahriman.base package_aur_mock.assert_has_calls([ MockCall(package_python_schedule.base, package_ahriman.packager, include_provides=True), MockCall("python-installer", package_ahriman.packager, include_provides=True), @@ -148,7 +149,10 @@ def test_with_dependencies_exception(application: Application, package_ahriman: mocker.patch("ahriman.application.application.Application._known_packages", return_value={"devtools", "python-build", "python-pytest"}) - assert not application.with_dependencies([package_ahriman], process_dependencies=True) + plan = BuildPlan() + plan.add(package_ahriman, BuildPlanReason.RegularUpdate) + assert application.with_dependencies(plan, process_dependencies=True) is plan + assert plan.packages == [package_ahriman] def test_with_dependencies_skip(application: Application, package_ahriman: Package, mocker: MockerFixture) -> None: @@ -157,8 +161,9 @@ def test_with_dependencies_skip(application: Application, package_ahriman: Packa """ packages_mock = mocker.patch("ahriman.application.application.Application._known_packages") - assert application.with_dependencies([package_ahriman], process_dependencies=False) == [package_ahriman] + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + assert application.with_dependencies(plan, process_dependencies=False).packages == [package_ahriman] packages_mock.assert_not_called() - assert application.with_dependencies([], process_dependencies=True) == [] + assert not application.with_dependencies(BuildPlan(), process_dependencies=True) packages_mock.assert_not_called() diff --git a/ahriman-core/tests/ahriman/application/handlers/test_handler_rebuild.py b/ahriman-core/tests/ahriman/application/handlers/test_handler_rebuild.py index 2a10b889..bcb7f531 100644 --- a/ahriman-core/tests/ahriman/application/handlers/test_handler_rebuild.py +++ b/ahriman-core/tests/ahriman/application/handlers/test_handler_rebuild.py @@ -2,12 +2,12 @@ import argparse import pytest from pytest_mock import MockerFixture -from unittest.mock import call as MockCall from ahriman.application.application import Application from ahriman.application.handlers.rebuild import Rebuild from ahriman.core.configuration import Configuration from ahriman.core.repository import Repository +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.build_status import BuildStatus, BuildStatusEnum from ahriman.models.package import Package from ahriman.models.packagers import Packagers @@ -48,15 +48,18 @@ def test_run(args: argparse.Namespace, package_ahriman: Package, configuration: application_packages_mock = mocker.patch("ahriman.core.repository.repository.Repository.packages_depend_on", return_value=[package_ahriman]) application_mock = mocker.patch("ahriman.application.application.Application.update", return_value=result) + print_mock = mocker.patch("ahriman.application.application.Application.print_updates") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") on_start_mock = mocker.patch("ahriman.application.application.Application.on_start") _, repository_id = configuration.check_loaded() Rebuild.run(args, repository_id, configuration, report=False) + plan = BuildPlan().update([package_ahriman], BuildPlanReason.Rebuild) extract_mock.assert_called_once_with(pytest.helpers.anyvar(int), args.status, from_database=args.from_database) application_packages_mock.assert_called_once_with([package_ahriman], None) - application_mock.assert_called_once_with([package_ahriman], Packagers(args.username), bump_pkgrel=args.increment) - check_mock.assert_has_calls([MockCall(False, [package_ahriman]), MockCall(False, True)]) + print_mock.assert_called_once_with(plan, pytest.helpers.anyvar(int), bump_pkgrel=args.increment) + application_mock.assert_called_once_with(plan, Packagers(args.username), bump_pkgrel=args.increment) + check_mock.assert_called_once_with(False, True) on_start_mock.assert_called_once_with() @@ -94,8 +97,9 @@ def test_run_dry_run(args: argparse.Namespace, configuration: Configuration, rep _, repository_id = configuration.check_loaded() Rebuild.run(args, repository_id, configuration, report=False) application_mock.assert_not_called() - check_mock.assert_called_once_with(False, [package_ahriman]) - print_mock.assert_called_once_with([package_ahriman], log_fn=pytest.helpers.anyvar(int)) + plan = BuildPlan().update([package_ahriman], BuildPlanReason.Rebuild) + check_mock.assert_called_once_with(False, plan) + print_mock.assert_called_once_with(plan, pytest.helpers.anyvar(int), bump_pkgrel=args.increment) def test_run_filter(args: argparse.Namespace, configuration: Configuration, repository: Repository, @@ -109,6 +113,7 @@ def test_run_filter(args: argparse.Namespace, configuration: Configuration, repo mocker.patch("ahriman.core.repository.Repository.load", return_value=repository) mocker.patch("ahriman.application.handlers.rebuild.Rebuild.extract_packages", return_value=[]) application_packages_mock = mocker.patch("ahriman.core.repository.repository.Repository.packages_depend_on") + mocker.patch("ahriman.application.application.Application.print_updates") _, repository_id = configuration.check_loaded() Rebuild.run(args, repository_id, configuration, report=False) @@ -125,6 +130,7 @@ def test_run_without_filter(args: argparse.Namespace, configuration: Configurati mocker.patch("ahriman.core.repository.Repository.load", return_value=repository) mocker.patch("ahriman.application.handlers.rebuild.Rebuild.extract_packages", return_value=[]) application_packages_mock = mocker.patch("ahriman.core.repository.repository.Repository.packages_depend_on") + mocker.patch("ahriman.application.application.Application.print_updates") _, repository_id = configuration.check_loaded() Rebuild.run(args, repository_id, configuration, report=False) @@ -147,7 +153,7 @@ def test_run_update_empty_exception(args: argparse.Namespace, configuration: Con _, repository_id = configuration.check_loaded() Rebuild.run(args, repository_id, configuration, report=False) - check_mock.assert_called_once_with(True, []) + check_mock.assert_called_once_with(True, BuildPlan()) def test_run_build_empty_exception(args: argparse.Namespace, configuration: Configuration, repository: Repository, @@ -161,11 +167,12 @@ def test_run_build_empty_exception(args: argparse.Namespace, configuration: Conf mocker.patch("ahriman.application.handlers.rebuild.Rebuild.extract_packages") mocker.patch("ahriman.core.repository.repository.Repository.packages_depend_on", return_value=[package_ahriman]) mocker.patch("ahriman.application.application.Application.update", return_value=Result()) + mocker.patch("ahriman.application.application.Application.print_updates") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") _, repository_id = configuration.check_loaded() Rebuild.run(args, repository_id, configuration, report=False) - check_mock.assert_has_calls([MockCall(True, [package_ahriman]), MockCall(True, False)]) + check_mock.assert_called_once_with(True, False) def test_extract_packages(application: Application, mocker: MockerFixture) -> None: diff --git a/ahriman-core/tests/ahriman/application/handlers/test_handler_service_updates.py b/ahriman-core/tests/ahriman/application/handlers/test_handler_service_updates.py index 7c18ddbc..3177c5d6 100644 --- a/ahriman-core/tests/ahriman/application/handlers/test_handler_service_updates.py +++ b/ahriman-core/tests/ahriman/application/handlers/test_handler_service_updates.py @@ -39,7 +39,7 @@ def test_run(args: argparse.Namespace, configuration: Configuration, repository: _, repository_id = configuration.check_loaded() ServiceUpdates.run(args, repository_id, configuration, report=False) package_mock.assert_called_once_with(package_ahriman.base, None) - application_mock.assert_called_once_with(verbose=True, log_fn=pytest.helpers.anyvar(int), separator=" -> ") + application_mock.assert_called_once_with(verbose=True, log_fn=pytest.helpers.anyvar(int), separator=": ") check_mock.assert_called_once_with(args.exit_code, False) diff --git a/ahriman-core/tests/ahriman/application/handlers/test_handler_update.py b/ahriman-core/tests/ahriman/application/handlers/test_handler_update.py index f0290e8a..3bb6fb01 100644 --- a/ahriman-core/tests/ahriman/application/handlers/test_handler_update.py +++ b/ahriman-core/tests/ahriman/application/handlers/test_handler_update.py @@ -9,6 +9,7 @@ from ahriman.application.handlers.update import Update from ahriman.core.configuration import Configuration from ahriman.core.repository import Repository from ahriman.models.package import Package +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.packagers import Packagers from ahriman.models.result import Result @@ -65,22 +66,23 @@ def test_perform_action(args: argparse.Namespace, application: Application, pack result.add_updated(package_ahriman) application_mock = mocker.patch("ahriman.application.application.Application.update", return_value=result) check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) dependencies_mock = mocker.patch("ahriman.application.application.Application.with_dependencies", - return_value=[package_ahriman]) - updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman]) + return_value=plan) + updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=plan) changes_mock = mocker.patch("ahriman.application.application.Application.changes") print_mock = mocker.patch("ahriman.application.application.Application.print_updates") Update.perform_action(application, args) - application_mock.assert_called_once_with([package_ahriman], + application_mock.assert_called_once_with(plan, Packagers(args.username, {package_ahriman.base: "packager"}), bump_pkgrel=args.increment) updates_mock.assert_called_once_with( args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, check_files=args.check_files) - changes_mock.assert_called_once_with([package_ahriman]) - dependencies_mock.assert_called_once_with([package_ahriman], process_dependencies=args.dependencies) + changes_mock.assert_called_once_with(plan) + dependencies_mock.assert_called_once_with(plan, process_dependencies=args.dependencies) check_mock.assert_called_once_with(False, True) - print_mock.assert_called_once_with([package_ahriman], log_fn=pytest.helpers.anyvar(int)) + print_mock.assert_called_once_with(plan, pytest.helpers.anyvar(int), bump_pkgrel=args.increment) def test_perform_action_empty_exception(args: argparse.Namespace, application: Application, @@ -91,11 +93,13 @@ def test_perform_action_empty_exception(args: argparse.Namespace, application: A args = _default_args(args) args.exit_code = True args.dry_run = True - mocker.patch("ahriman.application.application.Application.updates", return_value=[]) + mocker.patch("ahriman.application.application.Application.updates", return_value=BuildPlan()) + print_mock = mocker.patch("ahriman.application.application.Application.print_updates") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") Update.perform_action(application, args) - check_mock.assert_called_once_with(True, []) + print_mock.assert_called_once_with(BuildPlan(), pytest.helpers.anyvar(int), bump_pkgrel=args.increment) + check_mock.assert_called_once_with(True, BuildPlan()) def test_perform_action_update_empty_exception(args: argparse.Namespace, application: Application, @@ -106,10 +110,11 @@ def test_perform_action_update_empty_exception(args: argparse.Namespace, applica args = _default_args(args) args.exit_code = True mocker.patch("ahriman.application.application.Application.update", return_value=Result()) - mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman]) - mocker.patch("ahriman.application.application.Application.with_dependencies", return_value=[package_ahriman]) - mocker.patch("ahriman.application.application.Application.print_updates") + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + mocker.patch("ahriman.application.application.Application.updates", return_value=plan) + mocker.patch("ahriman.application.application.Application.with_dependencies", return_value=plan) mocker.patch("ahriman.application.application.Application.changes") + mocker.patch("ahriman.application.application.Application.print_updates") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") Update.perform_action(application, args) @@ -125,15 +130,21 @@ def test_perform_action_dry_run(args: argparse.Namespace, application: Applicati args.dry_run = True application_mock = mocker.patch("ahriman.application.application.Application.update") check_mock = mocker.patch("ahriman.application.handlers.handler.Handler.check_status") - updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=[package_ahriman]) + print_mock = mocker.patch("ahriman.application.application.Application.print_updates") + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + dependencies_mock = mocker.patch("ahriman.application.application.Application.with_dependencies", + return_value=plan) + updates_mock = mocker.patch("ahriman.application.application.Application.updates", return_value=plan) changes_mock = mocker.patch("ahriman.application.application.Application.changes") Update.perform_action(application, args) updates_mock.assert_called_once_with( args.package, aur=args.aur, local=args.local, manual=args.manual, vcs=args.vcs, check_files=args.check_files) application_mock.assert_not_called() - changes_mock.assert_called_once_with([package_ahriman]) - check_mock.assert_called_once_with(False, [package_ahriman]) + changes_mock.assert_called_once_with(plan) + dependencies_mock.assert_called_once_with(plan, process_dependencies=args.dependencies) + print_mock.assert_called_once_with(plan, pytest.helpers.anyvar(int), bump_pkgrel=args.increment) + check_mock.assert_called_once_with(False, plan) def test_perform_action_no_changes(args: argparse.Namespace, application: Application, mocker: MockerFixture) -> None: @@ -145,7 +156,9 @@ def test_perform_action_no_changes(args: argparse.Namespace, application: Applic args.changes = False mocker.patch("ahriman.application.application.Application.update") mocker.patch("ahriman.application.handlers.handler.Handler.check_status") - mocker.patch("ahriman.application.application.Application.updates") + mocker.patch("ahriman.application.application.Application.updates", return_value=BuildPlan()) + mocker.patch("ahriman.application.application.Application.with_dependencies", return_value=BuildPlan()) + mocker.patch("ahriman.application.application.Application.print_updates") changes_mock = mocker.patch("ahriman.application.application.Application.changes") Update.perform_action(application, args) diff --git a/ahriman-core/tests/ahriman/core/formatters/conftest.py b/ahriman-core/tests/ahriman/core/formatters/conftest.py index 6e993d65..c37566f7 100644 --- a/ahriman-core/tests/ahriman/core/formatters/conftest.py +++ b/ahriman-core/tests/ahriman/core/formatters/conftest.py @@ -23,6 +23,7 @@ from ahriman.core.formatters import ( VersionPrinter ) from ahriman.models.aur_package import AURPackage +from ahriman.models.build_plan import BuildPlan, BuildPlanReason from ahriman.models.build_status import BuildStatus from ahriman.models.changes import Changes from ahriman.models.package import Package @@ -219,7 +220,8 @@ def update_printer(package_ahriman: Package) -> UpdatePrinter: Returns: UpdatePrinter: update printer test instance """ - return UpdatePrinter(package_ahriman, None) + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + return UpdatePrinter(plan, {}) @pytest.fixture diff --git a/ahriman-core/tests/ahriman/core/formatters/test_printer.py b/ahriman-core/tests/ahriman/core/formatters/test_printer.py index 456b8558..cad27b44 100644 --- a/ahriman-core/tests/ahriman/core/formatters/test_printer.py +++ b/ahriman-core/tests/ahriman/core/formatters/test_printer.py @@ -53,6 +53,18 @@ def test_print_indent(mocker: MockerFixture) -> None: log_mock.assert_has_calls([MockCall("key: value"), MockCall("\tkey: value"), MockCall("\t\tkey: value")]) +def test_print_separator(mocker: MockerFixture) -> None: + """ + must use property separator instead of default separator + """ + log_mock = MagicMock() + + mocker.patch("ahriman.core.formatters.Printer.properties", return_value=[Property("key", "value", separator=" ")]) + Printer().print(verbose=True, log_fn=log_mock) + + log_mock.assert_called_once_with("\tkey value") + + def test_properties() -> None: """ must return empty properties list diff --git a/ahriman-core/tests/ahriman/core/formatters/test_update_printer.py b/ahriman-core/tests/ahriman/core/formatters/test_update_printer.py index 37dd0e9a..2e5d9d9a 100644 --- a/ahriman-core/tests/ahriman/core/formatters/test_update_printer.py +++ b/ahriman-core/tests/ahriman/core/formatters/test_update_printer.py @@ -1,4 +1,6 @@ from ahriman.core.formatters import UpdatePrinter +from ahriman.models.build_plan import BuildPlan, BuildPlanReason +from ahriman.models.package import Package from ahriman.models.property import Property @@ -13,25 +15,52 @@ def test_properties_na(update_printer: UpdatePrinter) -> None: """ must return N/A if local version is unknown """ - assert update_printer.properties() == [Property("N/A", update_printer.package.version, is_required=True)] + package = update_printer.plan.packages[0] + assert update_printer.properties() == [ + Property(package.base, "", is_required=True), + Property("N/A", package.version, is_required=True, indent=2, separator=" -> "), + Property("Reason", BuildPlanReason.RegularUpdate.value, indent=2), + ] -def test_properties_bump_pkgrel(update_printer: UpdatePrinter) -> None: +def test_properties_package_required_by(package_python_schedule: Package) -> None: + """ + must include requestee package to properties + """ + plan = BuildPlan() + plan.add(package_python_schedule, BuildPlanReason.RequiredBy, requester="ahriman") + + properties = list(UpdatePrinter(plan, {}, bump_pkgrel=False).properties_package(package_python_schedule)) + assert properties[-1].value == "required by ahriman" + + +def test_versions_bump_pkgrel(update_printer: UpdatePrinter) -> None: """ must bump pkgrel if local version is the same """ - update_printer.local_version = update_printer.package.version - assert update_printer.properties() == [Property(update_printer.package.version, "2.6.0-1.1", is_required=True)] + package = update_printer.plan.packages[0] + update_printer.local_versions[package.base] = package.version + assert update_printer.versions(package) == (package.version, "2.6.0-1.1") -def test_properties_keep_pkgrel(update_printer: UpdatePrinter) -> None: +def test_versions_keep_pkgrel(update_printer: UpdatePrinter) -> None: """ must keep pkgrel if local version is not the same """ - update_printer.local_version = "2.5.0-1" - assert update_printer.properties() == [ - Property(update_printer.local_version, update_printer.package.version, is_required=True), - ] + package = update_printer.plan.packages[0] + update_printer.local_versions[package.base] = "2.5.0-1" + assert update_printer.versions(package) == ("2.5.0-1", package.version) + + +def test_versions_no_increment(update_printer: UpdatePrinter) -> None: + """ + must preserve the package version when release incrementing is disabled + """ + package = update_printer.plan.packages[0] + update_printer.local_versions[package.base] = package.version + update_printer.bump_pkgrel = False + + assert update_printer.versions(package) == (package.version, package.version) def test_title(update_printer: UpdatePrinter) -> None: diff --git a/ahriman-core/tests/ahriman/models/test_build_plan.py b/ahriman-core/tests/ahriman/models/test_build_plan.py new file mode 100644 index 00000000..635cafef --- /dev/null +++ b/ahriman-core/tests/ahriman/models/test_build_plan.py @@ -0,0 +1,52 @@ +from ahriman.models.build_plan import BuildPlan, BuildPlanReason +from ahriman.models.package import Package + + +def test_add(package_ahriman: Package, package_python_schedule: Package) -> None: + """ + must replace the package and reason for the same base + """ + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + plan.add(package_ahriman, BuildPlanReason.QueuedRequest) + plan.add(package_python_schedule, BuildPlanReason.LocalSourceUpdate) + + assert package_ahriman in plan + assert package_python_schedule in plan + assert plan.item(package_ahriman.base).reason == BuildPlanReason.QueuedRequest + + +def test_add_with_requester(package_python_schedule: Package) -> None: + """ + must keep the last requester for a dependency + """ + plan = BuildPlan() + plan.add(package_python_schedule, BuildPlanReason.RequiredBy, requester="ahriman") + plan.add(package_python_schedule, BuildPlanReason.RequiredBy, requester="python-ahriman") + + assert plan.item(package_python_schedule.base).requester == "python-ahriman" + + +def test_update(package_ahriman: Package) -> None: + """ + must update instance with new packages + """ + plan = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + assert package_ahriman in plan + + +def test_eq(package_ahriman: Package) -> None: + """ + must compare two plans + """ + plan1 = BuildPlan().update([package_ahriman], BuildPlanReason.RegularUpdate) + assert plan1 == plan1 + + plan2 = BuildPlan().update([package_ahriman], BuildPlanReason.QueuedRequest) + assert plan1 != plan2 + + +def test_eq_other() -> None: + """ + must return False in case if object is not an instance of build plan + """ + assert BuildPlan() != 42 diff --git a/docker/Dockerfile b/docker/Dockerfile index b0348fd3..2bfab1bf 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -7,14 +7,15 @@ ARG BUILD_DATE ## create build user RUN useradd -m -d "/home/build" -s "/usr/bin/nologin" build -## extract container creation date and set mirror for this timestamp, set PKGEXT and refresh database next -RUN echo "Server = https://archive.archlinux.org/repos/${BUILD_DATE//-//}/\$repo/os/\$arch" > "/etc/pacman.d/mirrorlist" && \ - pacman -Syyuu --noconfirm +## extract container creation date and set mirror for this timestamp +RUN echo "Server = https://archive.archlinux.org/repos/${BUILD_DATE//-//}/\$repo/os/\$arch" > "/etc/pacman.d/mirrorlist" ## setup package cache RUN runuser -u build -- mkdir "/tmp/pkg" && \ echo "PKGDEST=/tmp/pkg" >> "/etc/makepkg.conf" && \ echo "[options]" >> "/etc/pacman.conf" && \ echo "CacheDir = /tmp/pkg/" >> "/etc/pacman.conf" +## refresh root image +RUN pacman -Syyuu --noconfirm ## install anc configure sudo RUN pacman -S --noconfirm --asdeps sudo && \ diff --git a/docs/ahriman.models.rst b/docs/ahriman.models.rst index 99f34a95..65f985df 100644 --- a/docs/ahriman.models.rst +++ b/docs/ahriman.models.rst @@ -28,6 +28,14 @@ ahriman.models.auth\_settings module :no-undoc-members: :show-inheritance: +ahriman.models.build\_plan module +--------------------------------- + +.. automodule:: ahriman.models.build_plan + :members: + :no-undoc-members: + :show-inheritance: + ahriman.models.build\_status module -----------------------------------