Release 2.0.0rc2

Old versions cached full output to memory and only after that printed it
into log. This behaviour causes issues in case if operation stucks and
you would need to find the step at which it does. New check_output
method uses Popen directly and iterates over stdout lines

Also changed behaviour from merging stderr into stdout to separate
stderr logging.

Any other behaviour of the function must be the same.

Also changed GPG.key_import method to disable local signing since it
seems it is useless (and may break process in case if there is no
private key)

.bandit-test.yml

@@ -1 +1 @@
-skips: ['B101', 'B404']
+skips: ['B101', 'B105', 'B404']

.github/workflows/docker-image.yml

@@ -0,0 +1,39 @@
+name: docker image
+
+on:
+  push:
+    branches: [ master ]
+
+jobs:
+  docker-image:
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: extract docker metadata
+        id: meta
+        uses: docker/metadata-action@v3
+        with:
+          images: |
+            arcan1s/ahriman
+          tags: |
+            type=ref,event=tag
+            type=edge
+
+      - name: setup QEMU
+        uses: docker/setup-qemu-action@v1
+
+      - name: setup docker buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: login to docker hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: build an image and push
+        uses: docker/build-push-action@v2
+        with:
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}

.github/workflows/release.yml

@@ -12,20 +12,24 @@ jobs:
 
     steps:
       - uses: actions/checkout@v2
+
       - name: extract version
         id: version
         run: echo ::set-output name=VERSION::${GITHUB_REF#refs/tags/}
+
       - name: create changelog
         id: changelog
         uses: jaywcjlove/changelog-generator@main
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           filter: 'Release \d+\.\d+\.\d+'
+
       - name: create archive
         run: make archive
         env:
           VERSION: ${{ steps.version.outputs.VERSION }}
-      - name: Release
+
+      - name: release
         uses: softprops/action-gh-release@v1
         with:
           body: |

.github/workflows/run-setup.yml

@@ -0,0 +1,24 @@
+name: setup
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  run-setup:
+
+    runs-on: ubuntu-latest
+
+    container:
+      image: archlinux:latest
+      volumes:
+        - ${{ github.workspace }}:/build
+      options: --privileged -w /build
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: setup the service in arch linux container
+        run: .github/workflows/setup.sh

.github/workflows/run-tests.yml

@@ -11,16 +11,14 @@ jobs:
 
     runs-on: ubuntu-latest
 
+    container:
+      image: archlinux:latest
+      volumes:
+        - ${{ github.workspace }}:/build
+      options: -w /build
+
     steps:
       - uses: actions/checkout@v2
+
       - name: run check and tests in arch linux container
-        run: |
-          docker run \
-          -v  ${{ github.workspace }}:/build -w /build \
-          archlinux:latest \
-          /bin/bash -c "pacman --noconfirm -Syu base-devel python-argparse-manpage python-pip && \
-          pip install -e .[web] && \
-          pip install -e .[check] && \
-          pip install -e .[s3] && \
-          pip install -e .[test] && \
-          make check tests"
+        run: .github/workflows/tests.sh

.github/workflows/setup.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# Install the package and run main install commands
+
+set -ex
+
+# install dependencies
+echo -e '[arcanisrepo]\nServer = http://repo.arcanis.me/$arch\nSigLevel = Never' | tee -a /etc/pacman.conf
+# refresh the image
+pacman --noconfirm -Syu
+# main dependencies
+pacman --noconfirm -Sy base-devel devtools git pyalpm python-aur python-passlib python-srcinfo sudo
+# make dependencies
+pacman --noconfirm -Sy python-build python-installer python-wheel
+# optional dependencies
+# VCS support
+pacman --noconfirm -Sy breezy darcs mercurial subversion
+# web server
+pacman --noconfirm -Sy python-aioauth-client python-aiohttp python-aiohttp-debugtoolbar python-aiohttp-jinja2 python-aiohttp-security python-aiohttp-session python-cryptography python-jinja
+# additional features
+pacman --noconfirm -Sy gnupg python-boto3 rsync
+
+# create fresh tarball
+make VERSION=1.0.0 archlinux  # well, it does not really matter which version we will put here
+# run makepkg
+mv ahriman-*-src.tar.xz package/archlinux
+chmod +777 package/archlinux  # because fuck you that's why
+cd package/archlinux
+sudo -u nobody -- makepkg -cf --skipchecksums --noconfirm
+pacman --noconfirm -U ahriman-1.0.0-1-any.pkg.tar.zst
+# create machine-id which is required by build tools
+systemd-machine-id-setup
+
+# special thing for the container, because /dev/log interface is not available there
+sed -i "s/handlers = syslog_handler/handlers = console_handler/g" /etc/ahriman.ini.d/logging.ini
+# initial setup command as root
+ahriman -a x86_64 repo-setup --packager "ahriman bot <ahriman@example.com>" --repository "github" --web-port 8080
+# enable services
+systemctl enable ahriman-web@x86_64
+systemctl enable ahriman@x86_64.timer
+# run web service (detached)
+sudo -u ahriman -- ahriman -a x86_64 web &
+WEBPID=$!
+sleep 15s  # wait for the web service activation
+# add the first package
+# the build itself does not really work in the container
+sudo -u ahriman -- ahriman package-add --now yay
+# check if package was actually installed
+#test -n "$(find "/var/lib/ahriman/repository/x86_64" -name "yay*pkg*")"
+# run package check
+sudo -u ahriman -- ahriman repo-update
+# stop web service lol
+kill $WEBPID

.github/workflows/tests.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# Install dependencies and run test in container
+
+set -ex
+
+# install dependencies
+pacman --noconfirm -Syu base-devel python-pip python-tox
+
+# run test and check targets
+make check tests

.gitignore

@@ -94,3 +94,6 @@ ENV/
 .venv/
 
 *.tar.xz
+status_cache.json
+
+*.db

Dockerfile

@@ -0,0 +1,52 @@
+FROM archlinux:base-devel
+
+# image configuration
+ENV AHRIMAN_ARCHITECTURE="x86_64"
+ENV AHRIMAN_DEBUG=""
+ENV AHRIMAN_FORCE_ROOT=""
+ENV AHRIMAN_HOST="0.0.0.0"
+ENV AHRIMAN_OUTPUT="syslog"
+ENV AHRIMAN_PACKAGER="ahriman bot <ahriman@example.com>"
+ENV AHRIMAN_PORT=""
+ENV AHRIMAN_REPOSITORY="aur-clone"
+ENV AHRIMAN_REPOSITORY_ROOT="/var/lib/ahriman/ahriman"
+ENV AHRIMAN_USER="ahriman"
+
+# install environment
+## install git which is required for AUR interaction and go for yay
+RUN pacman --noconfirm -Syu git go
+## create build user
+RUN useradd -m -d /home/build -s /usr/bin/nologin build && \
+    echo "build ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/build
+## install AUR helper
+RUN YAY_DIR="$(runuser -u build -- mktemp -d)" && \
+    git clone https://aur.archlinux.org/yay.git "$YAY_DIR" && \
+    cd "$YAY_DIR" && \
+    runuser -u build -- makepkg --noconfirm --install && \
+    cd - && rm -r "$YAY_DIR"
+## install package dependencies
+RUN runuser -u build -- yay --noconfirm -Sy devtools git pyalpm python-inflection python-passlib python-requests python-srcinfo && \
+    runuser -u build -- yay --noconfirm -Sy python-build python-installer python-wheel && \
+    runuser -u build -- yay --noconfirm -Sy breezy darcs mercurial python-aioauth-client python-aiohttp \
+                                            python-aiohttp-debugtoolbar python-aiohttp-jinja2 python-aiohttp-security \
+                                            python-aiohttp-session python-boto3 python-cryptography python-jinja \
+                                            rsync subversion
+
+# install ahriman
+## copy tree
+COPY --chown=build . "/home/build/ahriman"
+## create package archive and install it
+RUN cd "/home/build/ahriman" && \
+    make VERSION=$(python -c "from src.ahriman.version import __version__; print(__version__)") archlinux && \
+    cp ./*-src.tar.xz "package/archlinux" && \
+    cd "package/archlinux" && \
+    runuser -u build -- makepkg --noconfirm --install --skipchecksums && \
+    cd - && rm -r "/home/build/ahriman"
+
+VOLUME ["/var/lib/ahriman"]
+
+# minimal runtime ahriman setup
+COPY "docker/entrypoint.sh" "/usr/local/bin/entrypoint"
+ENTRYPOINT ["entrypoint"]
+# default command
+CMD ["repo-update"]

Makefile

@@ -3,7 +3,7 @@
 
 PROJECT := ahriman
 
-FILES := AUTHORS COPYING README.md docs package src setup.cfg setup.py
+FILES := AUTHORS COPYING README.md docs package src setup.py tox.ini web.png
 TARGET_FILES := $(addprefix $(PROJECT)/, $(FILES))
 IGNORE_FILES := package/archlinux src/.mypy_cache
 
@@ -24,13 +24,10 @@ archive_directory: $(TARGET_FILES)
 	find "$(PROJECT)" -depth -type d -name "*.egg-info" -execdir rm -rf {} +
 
 archlinux: archive
-	sed -i "s/pkgver=[0-9.]*/pkgver=$(VERSION)/" package/archlinux/PKGBUILD
+	sed -i "s/pkgver=.*/pkgver=$(VERSION)/" package/archlinux/PKGBUILD
 
-check: clean mypy
-	autopep8 --exit-code --max-line-length 120 -aa -i -j 0 -r "src/$(PROJECT)" "tests/$(PROJECT)"
-	pylint --rcfile=.pylintrc "src/$(PROJECT)"
-	bandit -c .bandit.yml -r "src/$(PROJECT)"
-	bandit -c .bandit-test.yml -r "tests/$(PROJECT)"
+check: clean
+	tox -e check
 
 clean:
 	find . -type f -name "$(PROJECT)-*-src.tar.xz" -delete
@@ -42,10 +39,6 @@ directory: clean
 man:
 	cd src &&  PYTHONPATH=. argparse-manpage --module ahriman.application.ahriman --function _parser --author "ahriman team" --project-name ahriman --author-email "" --url https://github.com/arcan1s/ahriman --output ../docs/ahriman.1
 
-mypy:
-	cd src && mypy --implicit-reexport --strict -p "$(PROJECT)" --install-types --non-interactive || true
-	cd src && mypy --implicit-reexport --strict -p "$(PROJECT)"
-
 push: architecture man archlinux
 	git add package/archlinux/PKGBUILD src/ahriman/version.py docs/ahriman-architecture.svg docs/ahriman.1
 	git commit -m "Release $(VERSION)"
@@ -54,10 +47,10 @@ push: architecture man archlinux
 	git push --tags
 
 tests: clean
-	python setup.py test
+	tox -e tests
 
 version:
 ifndef VERSION
 	$(error VERSION is required, but not set)
 endif
-	sed -i '/__version__ = "[0-9.]*/s/[^"][^)]*/__version__ = "$(VERSION)"/' src/ahriman/version.py
+	sed -i '/__version__ = .*/s/[^"][^)]*/__version__ = "$(VERSION)"/' src/ahriman/version.py

README.md

@@ -1,6 +1,8 @@
 # ArcH Linux ReposItory MANager
 
-[![build status](https://github.com/arcan1s/ahriman/actions/workflows/run-tests.yml/badge.svg)](https://github.com/arcan1s/ahriman/actions/workflows/run-tests.yml)
+[![tests status](https://github.com/arcan1s/ahriman/actions/workflows/run-tests.yml/badge.svg)](https://github.com/arcan1s/ahriman/actions/workflows/run-tests.yml)
+[![setup status](https://github.com/arcan1s/ahriman/actions/workflows/run-setup.yml/badge.svg)](https://github.com/arcan1s/ahriman/actions/workflows/run-setup.yml)
+[![docker image](https://github.com/arcan1s/ahriman/actions/workflows/docker-image.yml/badge.svg)](https://github.com/arcan1s/ahriman/actions/workflows/docker-image.yml)
 [![CodeFactor](https://www.codefactor.io/repository/github/arcan1s/ahriman/badge)](https://www.codefactor.io/repository/github/arcan1s/ahriman)
 
 Wrapper for managing custom repository inspired by [repo-scripts](https://github.com/arcan1s/repo-scripts).
@@ -11,62 +13,19 @@ Wrapper for managing custom repository inspired by [repo-scripts](https://github
 * Multi-architecture support.
 * VCS packages support.
 * Sign support with gpg (repository, package, per package settings).
-* Synchronization to remote services (rsync, s3) and report generation (html).
+* Synchronization to remote services (rsync, s3 and github) and report generation (html).
 * Dependency manager.
+* Ability to patch AUR packages and even create package from local PKGBUILDs.
 * Repository status interface with optional authorization and control options:
 
     ![web interface](web.png)
 
 ## Installation and run
 
-For installation details please refer to the [documentation](docs/setup.md). For command help, `--help` subcommand must be used, e.g.:
-
-```shell
-$ ahriman --help
-usage: ahriman [-h] [-a ARCHITECTURE] [-c CONFIGURATION] [--force] [-l LOCK] [--no-log] [--no-report] [--unsafe] [-v]
-               {add,check,clean,config,create-user,init,key-import,rebuild,remove,remove-unknown,report,search,setup,sign,status,status-update,sync,update,web} ...
-
-ArcH Linux ReposItory MANager
-
-optional arguments:
-  -h, --help            show this help message and exit
-  -a ARCHITECTURE, --architecture ARCHITECTURE
-                        target architectures (can be used multiple times) (default: None)
-  -c CONFIGURATION, --configuration CONFIGURATION
-                        configuration path (default: /etc/ahriman.ini)
-  --force               force run, remove file lock (default: False)
-  -l LOCK, --lock LOCK  lock file (default: /tmp/ahriman.lock)
-  --no-log              redirect all log messages to stderr (default: False)
-  --no-report           force disable reporting to web service (default: False)
-  --unsafe              allow to run ahriman as non-ahriman user (default: False)
-  -v, --version         show program's version number and exit
-
-command:
-  {add,check,clean,config,create-user,init,key-import,rebuild,remove,remove-unknown,report,search,setup,sign,status,status-update,sync,update,web}
-                        command to run
-    add                 add package
-    check               check for updates
-    clean               clean local caches
-    config              dump configuration
-    create-user         create user for web services
-    init                create repository tree
-    key-import          import PGP key
-    rebuild             rebuild repository
-    remove              remove package
-    remove-unknown      remove unknown packages
-    report              generate report
-    search              search for package
-    setup               initial service configuration
-    sign                sign packages
-    status              get package status
-    status-update       update package status
-    sync                sync repository
-    update              update packages
-    web                 start web server
-```
-
-Subcommands have own help message as well.
+For installation details please refer to the [documentation](docs/setup.md). For command help, `--help` subcommand must be used. Subcommands have own help message as well. The package also provides a [man page](docs/ahriman.1).
 
 ## Configuration
 
 Every available option is described in the [documentation](docs/configuration.md).
+
+## [FAQ](docs/faq.md)

docker/entrypoint.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+
+set -e
+[ -n "$AHRIMAN_DEBUG" ] && set -x
+
+# configuration tune
+sed -i "s|root = /var/lib/ahriman|root = $AHRIMAN_REPOSITORY_ROOT|g" "/etc/ahriman.ini"
+sed -i "s|database = /var/lib/ahriman/ahriman.db|database = $AHRIMAN_REPOSITORY_ROOT/ahriman.db|g" "/etc/ahriman.ini"
+sed -i "s|host = 127.0.0.1|host = $AHRIMAN_HOST|g" "/etc/ahriman.ini"
+sed -i "s|handlers = syslog_handler|handlers = ${AHRIMAN_OUTPUT}_handler|g" "/etc/ahriman.ini.d/logging.ini"
+
+AHRIMAN_DEFAULT_ARGS=("--architecture" "$AHRIMAN_ARCHITECTURE")
+if [[ "$AHRIMAN_OUTPUT" == "syslog" ]]; then
+    if [ ! -e "/dev/log" ]; then
+        # by default ahriman uses syslog which is not available inside container
+        # to make noise less we force quiet mode in case if /dev/log was not mounted
+        AHRIMAN_DEFAULT_ARGS+=("--quiet")
+    fi
+fi
+
+# create repository root inside the [[mounted]] directory and set correct ownership
+[ -d "$AHRIMAN_REPOSITORY_ROOT" ] || mkdir "$AHRIMAN_REPOSITORY_ROOT"
+chown "$AHRIMAN_USER":"$AHRIMAN_USER" "$AHRIMAN_REPOSITORY_ROOT"
+
+# run built-in setup command
+AHRIMAN_SETUP_ARGS=("--build-as-user" "$AHRIMAN_USER")
+AHRIMAN_SETUP_ARGS+=("--packager" "$AHRIMAN_PACKAGER")
+AHRIMAN_SETUP_ARGS+=("--repository" "$AHRIMAN_REPOSITORY")
+if [ -n "$AHRIMAN_PORT" ]; then
+    # in addition it must be handled in docker run command
+    AHRIMAN_SETUP_ARGS+=("--web-port" "$AHRIMAN_PORT")
+fi
+ahriman "${AHRIMAN_DEFAULT_ARGS[@]}" repo-setup "${AHRIMAN_SETUP_ARGS[@]}"
+
+# refresh database
+runuser -u build -- yay --noconfirm -Syy &> /dev/null
+# create machine-id which is required by build tools
+systemd-machine-id-setup &> /dev/null
+
+# if AHRIMAN_FORCE_ROOT is set or command is unsafe we can run without sudo
+# otherwise we prepend executable by sudo command
+if [ -n "$AHRIMAN_FORCE_ROOT" ]; then
+    AHRIMAN_EXECUTABLE=("ahriman")
+elif ahriman help-commands-unsafe --command="$*" &> /dev/null; then
+    AHRIMAN_EXECUTABLE=("sudo" "-u" "$AHRIMAN_USER" "--" "ahriman")
+else
+    AHRIMAN_EXECUTABLE=("ahriman")
+fi
+exec "${AHRIMAN_EXECUTABLE[@]}" "${AHRIMAN_DEFAULT_ARGS[@]}" "$@"

docs/architecture.md

@@ -12,7 +12,11 @@ Full dependency diagram:
 
 ## `ahriman.application` package
 
-This package contains application (aka executable) related classes and everything for that. It also contains package called `ahriman.application.handlers` in which all available subcommands are described as separated classes derived from base `ahriman.application.handlers.handler.Handler` class. `ahriman.application.ahriman` contains only command line parses and executes specified `Handler` on success, `ahriman.application.application.Application` is a god class which provides interfaces for all repository related actions. `ahriman.application.lock.Lock` is additional class which provides file-based lock and also performs some common checks.
+This package contains application (aka executable) related classes and everything for that. It also contains package called `ahriman.application.handlers` in which all available subcommands are described as separated classes derived from base `ahriman.application.handlers.handler.Handler` class.
+
+`ahriman.application.application.application.Application` (god class) is used for any interaction from parsers with repository, web etc. It is divided into multiple traits by functions (package related and repository related) in the same package.
+
+`ahriman.application.ahriman` contains only command line parses and executes specified `Handler` on success, `ahriman.application.lock.Lock` is additional class which provides file-based lock and also performs some common checks.
 
 ## `ahriman.core` package
 
@@ -21,6 +25,8 @@ This package contains everything which is required for any time of application r
 * `ahriman.core.alpm` package controls pacman related functions. It provides wrappers for `pyalpm` library and safe calls for repository tools (`repo-add` and `repo-remove`).
 * `ahriman.core.auth` package provides classes for authorization methods used by web mostly. Base class is `ahriman.core.auth.auth.Auth` which must be called by `load` method.
 * `ahriman.core.build_tools` is a package which provides wrapper for `devtools` commands.
+* `ahriman.core.database` is everything including data and schema migrations for database.
+* `ahriman.core.formatters` package provides `Printer` sub-classes for printing data (e.g. package properties) to stdout which are used by some handlers.
 * `ahriman.core.report` is a package with reporting classes. Usually it must be called by `ahriman.core.report.report.Report.load` method.
 * `ahriman.core.repository` contains several traits and base repository (`ahriman.core.repository.repository.Repository` class) implementation.
 * `ahriman.core.sign` package provides sign feature (only gpg calls are available).
@@ -55,11 +61,34 @@ Web application. It is important that this package is isolated from any other to
 * In each child process call lock functions.
 * After success checks pass control to `Handler.run` method defined by specific handler class.
 * Return result (success or failure) of each subprocess and exit from application.
+* Some handlers may override their status and throw `ExitCode` exception. This exception is just silently suppressed and changes application exit code to `1`.
 
 In most cases handlers spawn god class `ahriman.application.application.Application` class and call required methods.
 
 Application is designed to run from `systemd` services and provides parametrized by architecture timer and service file for that.
 
+# Database
+
+The service uses SQLite database in order to store some internal info.
+
+## Database instance
+
+All methods related to specific part of database (basically operations per table) are split into different traits located inside `ahriman.core.database.operations` package. The base trait `ahriman.core.database.operations.operations.Operations` also provides generic methods for database access (e.g. row converters and transactional support).
+
+The `ahriman.core.database.sqlite.SQLite` class itself derives from all of these traits and implements methods for initialization, including migrations.
+
+## Schema and data migrations
+
+The schema migration are applied according to current `pragma user_info` values, located at `ahriman.core.database.migrations` package and named as `m000_migration_name.py` (the preceding `m` is required in order to import migration content for tests). Additional class `ahriman.core.database.migrations.Migrations` reads all migrations autmatically and applies them in alphabetical order.
+
+There are also data migrations which are located at `ahriman.core.database.data` package and move data from old-style (e.g. json files in filesystem, directory trees, etc) to the database. They are also part of migration and (unlike schema migrations) are applied only at specific version breakpoints (e.g. if `user_version` is more than 0 no initial migration will be applied).
+
+## Type conversions
+
+By default, it parses rows into python dictionary. In addition, the following pseudo-types are supported:
+
+* `Dict[str, Any]`, `List[Any]` - for storing JSON data structures in database (technically there is no restriction on types for dictionary keys and values, but it is recommended to use only string keys). The type is stored as `json` datatype and `json.loads` and `json.dumps` methods are used in order to read and write from/to database respectively.
+
 # Basic flows
 
 ## Add new packages or rebuild existing
@@ -67,8 +96,11 @@ Application is designed to run from `systemd` services and provides parametrized
 Idea is to copy package to the directory from which it will be handled at the next update run. Different variants are supported:
 
 * If supplied argument is file then application moves the file to the directory with built packages. Same rule applies for directory, but in this case it copies every package-like file from the specified directory.
+* If supplied argument is directory and there is `PKGBUILD` file there it will be treated as local package. In this case it will queue this package to build and copy source files (`PKGBUILD` and `.SRCINFO`) to caches.
 * If supplied argument iis not file then application tries to lookup for the specified name in AUR and clones it into the directory with manual updates. This scenario can also handle package dependencies which are missing in repositories.
 
+This logic can be overwritten by specifying the `source` parameter, which is partially useful if you would like to add package from AUR, but there is local directory cloned from AUR.
+
 ## Rebuild packages
 
 Same as add function for every package in repository. Optional filter by reverse dependency can be supplied.
@@ -97,7 +129,7 @@ After any step any package data is being removed.
 
 ## Configuration 
 
-`ahriman.core.configuration.Configuration` class provides some additional methods (e.g. `getpath` and `getlist`) and also combines multiple files into single configuration dictionary using architecture overrides. It is recommended to read class related settings from the class, not outside.
+`ahriman.core.configuration.Configuration` class provides some additional methods (e.g. `getpath` and `getlist`) and also combines multiple files into single configuration dictionary using architecture overrides. It is the recommended way to deal with settings.
 
 ## Utils
 
@@ -105,7 +137,7 @@ For every external command run (which is actually not recommended if possible) c
 
 ## Submodules
 
-Some packages provide different behaviour depending on configuration settings. In this cases inheritance is used and recommended way to deal with them is to call class method `load` from base classes.
+Some packages provide different behaviour depending on configuration settings. In these cases inheritance is used and recommended way to deal with them is to call class method `load` from base classes.
 
 ## Authorization
 
@@ -113,25 +145,35 @@ The package provides several authorization methods: disabled, based on configura
 
 Disabled (default) authorization provider just allows everything for everyone and does not have any specific configuration (it uses some default configuration parameters though). It also provides generic interface for derived classes.
 
-Mapping (aka configuration) provider uses hashed passwords with salt from configuration file in order to authenticate users. This provider also enables user permission checking (read/write) (authorization). Thus, it defines the following methods:
+Mapping (aka configuration) provider uses hashed passwords with salt from the database in order to authenticate users. This provider also enables user permission checking (read/write) (authorization). Thus, it defines the following methods:
 
 * `check_credentials` - user password validation (authentication).
 * `verify_access` - user permission validation (authorization).
 
-Passwords must be stored in configuration as `hash(password + salt)`, where `password` is user defined password (taken from user input), `salt` is random string (any length) defined globally in configuration and `hash` is secure hash function. Thus, the following configuration
+Passwords must be stored in database as `hash(password + salt)`, where `password` is user defined password (taken from user input), `salt` is random string (any length) defined globally in configuration and `hash` is secure hash function. Thus, the following configuration
 
-```ini
-[auth:read]
-username = $6$rounds=656000$mWBiecMPrHAL1VgX$oU4Y5HH8HzlvMaxwkNEJjK13ozElyU1wAHBoO/WW5dAaE4YEfnB0X3FxbynKMl4FBdC3Ovap0jINz4LPkNADg0
+```csv
+"username","password","access"
+"username","$6$rounds=656000$mWBiecMPrHAL1VgX$oU4Y5HH8HzlvMaxwkNEJjK13ozElyU1wAHBoO/WW5dAaE4YEfnB0X3FxbynKMl4FBdC3Ovap0jINz4LPkNADg0","read"
 ```
 
 means that there is user `username` with `read` access and password `password` hashed by `sha512` with salt `salt`.
 
-OAuth provider uses library definitions (`aioauth-client`) in order _authenticate_ users. It still requires user permission to be set in configuration, thus it inherits mapping provider without any changes. Whereas we could override `check_credentials` (authentication method) by something custom, OAuth flow is a bit more complex than just forward request, thus we have to implement the flow in login form.
+OAuth provider uses library definitions (`aioauth-client`) in order _authenticate_ users. It still requires user permission to be set in database, thus it inherits mapping provider without any changes. Whereas we could override `check_credentials` (authentication method) by something custom, OAuth flow is a bit more complex than just forward request, thus we have to implement the flow in login form.
 
 OAuth's implementation also allows authenticating users via username + password (in the same way as mapping does) though it is not recommended for end-users and password must be left blank. In particular this feature is used by service reporting (aka robots).
 
-In order to configure users there is special command.
+In order to configure users there are special commands.
+
+## Remote synchronization
+
+There are several supported synchronization providers, currently they are `rsync`, `s3`, `github`. 
+
+`rsync` provider does not have any specific logic except for running external rsync application with configured arguments. The service does not handle SSH configuration, thus it has to be configured before running application manually.
+
+`s3` provider uses `boto3` package and implements sync feature. The files are stored in architecture directory (e.g. if bucket is `repository`, packages will be stored in `repository/x86_64` for the `x86_64` architecture), bucket must be created before any action and API key must have permissions to write to the bucket. No external configuration required. In order to upload only changed files the service compares calculated hashes with the Amazon ETags, used realization is described [here](https://teppen.io/2018/10/23/aws_s3_verify_etags/). 
+
+`github` provider authenticates through basic auth, API key with repository write permissions is required. There will be created a release with the name of the architecture in case if it does not exist; files will be uploaded to the release assets. It also stores array of files and their MD5 checksums in release body in order to upload only changed ones. According to the Github API in case if there is already uploaded asset with the same name (e.g. database files), asset will be removed first.
 
 ## Additional features
 

docs/configuration.md

@@ -1,12 +1,22 @@
 # ahriman configuration
 
-Some groups can be specified for each architecture separately. E.g. if there are `build` and `build:x86_64` groups it will use the option from `build:x86_64` for the `x86_64` architecture and `build` for any other (architecture specific group has higher priority). In case if both groups are presented, architecture specific options will be merged into global ones overriding them. 
+Some groups can be specified for each architecture separately. E.g. if there are `build` and `build:x86_64` groups it will use the option from `build:x86_64` for the `x86_64` architecture and `build` for any other (architecture specific group has higher priority). In case if both groups are presented, architecture specific options will be merged into global ones overriding them.
+
+There are two variable types which have been added to default ones, they are paths and lists. List values will be read in the same way as shell does:
+
+* By default, it splits value by spaces excluding empty elements. 
+* In case if quotation mark (`"` or `'`) will be found, any spaces inside will be ignored.
+* In order to use quotation mark inside value it is required to put it to another quotation mark, e.g. `wor"'"d "with quote"` will be parsed as `["wor'd", "with quote"]` and vice versa.
+* Unclosed quotation mark is not allowed and will rise an exception.
+
+Path values, except for casting to `pathlib.Path` type, will be also expanded to absolute paths relative to the configuration path. E.g. if path is set to `ahriman.ini.d/logging.ini` and root configuration path is `/etc/ahriman.ini`, the value will be expanded to `/etc/ahriman.ini.d/logging.ini`. In order to disable path expand, use the full path, e.g. `/etc/ahriman.ini.d/logging.ini`. 
 
 ## `settings` group
 
 Base configuration settings.
 
 * `include` - path to directory with configuration files overrides, string, required.
+* `database` - path to SQLite database, string, required.
 * `logging` - path to logging configuration, string, required. Check `logging.ini` for reference.
 
 ## `alpm` group
@@ -31,18 +41,11 @@ Base authorization settings. `OAuth` provider requires `aioauth-client` library
 * `safe_build_status` - allow requesting status page without authorization, boolean, required.
 * `salt` - password hash salt, string, required in case if authorization enabled (automatically generated by `create-user` subcommand).
 
-## `auth:*` groups
-
-Authorization mapping. Group name must refer to user access level, i.e. it should be one of `auth:read` (read hidden pages), `auth:write` (everything is allowed).
-
-Key is always username (case-insensitive), option value depends on authorization provider:
-
-* `OAuth` - by default requires only usernames and ignores values. But in case of direct login method call (via POST request) it will act as `Mapping` authorization method.
-* `Mapping` (default) - reads salted password hashes from values, uses SHA512 in order to hash passwords. Password can be set by using `create-user` subcommand.
+Authorized users are stored inside internal database, if any of external provides are used the password field for non-service users must be empty. 
 
 ## `build:*` groups
 
-Build related configuration. Group name must refer to architecture, e.g. it should be `build:x86_64` for x86_64 architecture.
+Build related configuration. Group name can refer to architecture, e.g. `build:x86_64` can be used for x86_64 architecture specific settings.
 
 * `archbuild_flags` - additional flags passed to `archbuild` command, space separated list of strings, optional.
 * `build_command` - default build command, string, required.
@@ -59,7 +62,7 @@ Base repository settings.
 
 ## `sign:*` groups
 
-Settings for signing packages or repository. Group name must refer to architecture, e.g. it should be `sign:x86_64` for x86_64 architecture.
+Settings for signing packages or repository. Group name can refer to architecture, e.g. `sign:x86_64` can be used for x86_64 architecture specific settings.
 
 * `target` - configuration flag to enable signing, space separated list of strings, required. Allowed values are `package` (sign each package separately), `repository` (sign repository database file).
 * `key` - default PGP key, string, required. This key will also be used for database signing if enabled.
@@ -69,12 +72,25 @@ Settings for signing packages or repository. Group name must refer to architectu
 
 Report generation settings.
 
-* `target` - list of reports to be generated, space separated list of strings, required. Allowed values are `html`, `email`.
+* `target` - list of reports to be generated, space separated list of strings, required. It must point to valid section (or to section with architecture), e.g. `somerandomname` must point to existing section, `email` must point to one of `email` of `email:x86_64` (the one with architecture has higher priority). 
 
-### `email:*` groups
+Type will be read from several ways:
 
-Group name must refer to architecture, e.g. it should be `email:x86_64` for x86_64 architecture.
+* In case if `type` option set inside the section, it will be used.
+* Otherwise, it will look for type from section name removing architecture name.
+* And finally, it will use section name as type.
 
+### `console` type
+
+Section name must be either `console` (plus optional architecture name, e.g. `console:x86_64`) or random name with `type` set.
+
+* `use_utf` - use utf8 symbols in output if set and ascii otherwise, boolean, optional, default `yes`.
+
+### `email` type
+
+Section name must be either `email` (plus optional architecture name, e.g. `email:x86_64`) or random name with `type` set.
+
+* `type` - type of the report, string, optional, must be set to `email` if exists.
 * `full_template_path` - path to Jinja2 template for full package description index, string, optional.
 * `homepage` - link to homepage, string, optional.
 * `host` - SMTP host for sending emails, string, required.
@@ -88,10 +104,11 @@ Group name must refer to architecture, e.g. it should be `email:x86_64` for x86_
 * `template_path` - path to Jinja2 template, string, required.
 * `user` - SMTP user to authenticate, string, optional.
 
-### `html:*` groups
+### `html` type
 
-Group name must refer to architecture, e.g. it should be `html:x86_64` for x86_64 architecture.
+Section name must be either `html` (plus optional architecture name, e.g. `html:x86_64`) or random name with `type` set.
 
+* `type` - type of the report, string, optional, must be set to `html` if exists.
 * `path` - path to html report file, string, required.
 * `homepage` - link to homepage, string, optional.
 * `link_path` - prefix for HTML links, string, required.
@@ -101,19 +118,41 @@ Group name must refer to architecture, e.g. it should be `html:x86_64` for x86_6
 
 Remote synchronization settings.
 
-* `target` - list of synchronizations to be used, space separated list of strings, required. Allowed values are `rsync`, `s3`.
+* `target` - list of synchronizations to be used, space separated list of strings, required. It must point to valid section (or to section with architecture), e.g. `somerandomname` must point to existing section, `github` must point to one of `github` of `github:x86_64` (with architecture it has higher priority).
 
-### `rsync:*` groups
+Type will be read from several ways:
 
-Group name must refer to architecture, e.g. it should be `rsync:x86_64` for x86_64 architecture. Requires `rsync` package to be installed. Do not forget to configure ssh for user `ahriman`.
+* In case if `type` option set inside the section, it will be used.
+* Otherwise, it will look for type from section name removing architecture name.
+* And finally, it will use section name as type.
 
+### `github` type
+
+This feature requires Github key creation (see below). Section name must be either `github` (plus optional architecture name, e.g. `github:x86_64`) or random name with `type` set.
+
+* `type` - type of the upload, string, optional, must be set to `github` if exists.
+* `owner` - Github repository owner, string, required.
+* `password` - created Github API key. In order to create it do the following:
+  1. Go to [settings page](https://github.com/settings/profile).
+  2. Switch to [developers settings](https://github.com/settings/apps).
+  3. Switch to [personal access tokens](https://github.com/settings/tokens).
+  4. Generate new token. Required scope is `public_repo` (or `repo` for private repository support).
+* `repository` - Github repository name, string, required. Repository must be created before any action and must have active branch (e.g. with readme).
+* `username` - Github authorization user, string, required. Basically the same as `owner`.
+
+### `rsync` type
+
+Requires `rsync` package to be installed. Do not forget to configure ssh for user `ahriman`. Section name must be either `rsync` (plus optional architecture name, e.g. `rsync:x86_64`) or random name with `type` set.
+
+* `type` - type of the upload, string, optional, must be set to `rsync` if exists.
 * `command` - rsync command to run, space separated list of string, required.
-* `remote` - remote server to rsync (e.g. `1.2.3.4:5678:path/to/sync`), string, required.
+* `remote` - remote server to rsync (e.g. `1.2.3.4:path/to/sync`), string, required.
 
-### `s3:*` groups
+### `s3` type
 
-Group name must refer to architecture, e.g. it should be `s3:x86_64` for x86_64 architecture.
+Requires `boto3` library to be installed. Section name must be either `s3` (plus optional architecture name, e.g. `s3:x86_64`) or random name with `type` set.
 
+* `type` - type of the upload, string, optional, must be set to `github` if exists.
 * `access_key` - AWS access key ID, string, required.
 * `bucket` - bucket name (e.g. `bucket`), string, required.
 * `chunk_size` - chunk size for calculating entity tags, int, optional, default 8 * 1024 * 1024.
@@ -122,7 +161,7 @@ Group name must refer to architecture, e.g. it should be `s3:x86_64` for x86_64
 
 ## `web:*` groups
 
-Web server settings. If any of `host`/`port` is not set, web integration will be disabled. Group name must refer to architecture, e.g. it should be `web:x86_64` for x86_64 architecture.
+Web server settings. If any of `host`/`port` is not set, web integration will be disabled. Group name can refer to architecture, e.g. `web:x86_64` can be used for x86_64 architecture specific settings. This feature requires `aiohttp` libraries to be installed.
 
 * `address` - optional address in form `proto://host:port` (`port` can be omitted in case of default `proto` ports), will be used instead of `http://{host}:{port}` in case if set, string, optional. This option is required in case if `OAuth` provider is used.
 * `debug` - enable debug toolbar, boolean, optional, default `no`.

docs/faq.md

@@ -0,0 +1,539 @@
+# FAQ
+
+## General topics
+
+### What is the purpose of the project?
+
+This project has been created in order to maintain self-hosted Arch Linux user repository without manual intervention - checking for updates and building packages.
+
+### How do I install it?
+
+TL;DR
+
+```shell
+yay -S ahriman
+sudo ahriman -a x86_64 repo-setup --packager "ahriman bot <ahriman@example.com>" --repository "repository"
+systemctl enable --now ahriman@x86_64.timer
+```
+
+#### Long answer
+
+The idea is to install the package as usual, create working directory tree, create configuration for `sudo` and `devtools`. Detailed description of the setup instruction can be found [here](setup.md).
+
+### What does "architecture specific" mean? / How to configure for different architectures?
+
+Some sections can be configured per architecture. The service will merge architecture specific values into common settings. In order to specify settings for specific architecture you must point it in section name.
+
+For example, the section
+
+```ini
+[build]
+build_command = extra-x86_64-build
+```
+
+states that default build command is `extra-x86_64-build`. But if there is section
+
+```ini
+[build:i686]
+build_command = extra-i686-build
+```
+
+the `extra-i686-build` command will be used for `i686` architecture.
+
+### How to use reporter/upload settings?
+
+Normally you probably like to generate only one report for the specific type, e.g. only one email report. In order to do it you will need to have the following configuration:
+
+```ini
+[report]
+target = email
+
+[email]
+...
+```
+
+or in case of multiple architectures and _different_ reporting settings:
+
+```ini
+[report]
+target = email
+
+[email:i686]
+...
+
+[email:x86_64]
+...
+```
+
+But for some cases you would like to have multiple different reports with the same type (e.g. sending different templates to different addresses). For these cases you will need to specify section name in target and type in section, e.g. the following configuration can be used:
+
+```ini
+[report]
+target = email_1 email_2
+
+[email_1]
+type = email
+...
+
+[email_2]
+type = email
+...
+```
+
+### Okay, I've installed ahriman, how do I add new package?
+
+```shell
+sudo -u ahriman ahriman package-add ahriman --now
+```
+
+`--now` flag is totally optional and just run `repo-update` subcommand after the registering the new package, Thus the extended flow is the following:
+
+```shell
+sudo -u ahriman ahriman package-add ahriman
+sudo -u ahriman ahriman repo-update
+```
+
+### AUR is fine, but I would like to create package from local PKGBUILD
+
+TL;DR
+
+```shell
+sudo -u ahriman ahriman package-add /path/to/local/directory/with/PKGBUILD --now
+```
+
+Before using this command you will need to create local directory, put `PKGBUILD` there and generate `.SRCINFO` by using `makepkg --printsrcinfo > .SRCINFO` command. These packages will be stored locally and _will be ignored_ during automatic update; in order to update the package you will need to run `package-add` command again.
+
+### But I just wanted to change PKGBUILD from AUR a bit!
+
+Well it is supported also.
+
+1. Clone sources from AUR.
+2. Make changes you would like to (e.g. edit `PKGBUILD`, add external patches).
+3. Run `sudo -u ahriman ahriman patch-add /path/to/local/directory/with/PKGBUILD`.
+
+The last command will calculate diff from current tree to the `HEAD` and will store it locally. Patches will be applied on any package actions (e.g. it can be used for dependency management).
+
+### Package build fails because it cannot validate PGP signature of source files
+
+TL;DR
+
+```shell
+sudo -u ahriman ahriman key-import ...
+```
+
+### How do I check if there are new commits for VCS packages?
+
+Normally the service handles VCS packages correctly, but it requires additional dependencies:
+
+```shell
+pacman -S breezy darcs mercurial subversion
+```
+
+### I would like to remove package because it is no longer needed/moved to official repositories
+
+```shell
+sudo -u ahriman ahriman package-remove ahriman
+```
+
+Also, there is command `repo-remove-unknown` which checks packages in AUR and local storage and removes ones which have been removed.
+
+Remove commands also remove any package files (patches, caches etc).
+
+### There is new major release of %library-name%, how do I rebuild packages?
+
+TL;DR
+
+```shell
+sudo -u ahriman ahriman repo-rebuild --depends-on python
+```
+
+You can even rebuild the whole repository (which is particular useful in case if you would like to change packager) if you do not supply `--depends-on` option.
+
+However, note that you do not need to rebuild repository in case if you just changed signing option, just use `repo-sign` command instead. 
+
+### Hmm, I have packages built, but how can I use it?
+
+Add the following lines to your `pacman.conf`:
+
+```ini
+[repository]
+Server = file:///var/lib/ahriman/repository/x86_64
+```
+
+(You might need to add `SigLevel` option according to the pacman documentation.)
+
+
+### I would like to serve the repository
+
+Easy. For example, nginx configuration (without SSL) will look like:
+
+```
+server {
+    listen 80;
+    server_name repo.example.com;
+
+    location / {
+        autoindex on;
+        root /var/lib/ahriman/repository;
+    }
+}
+```
+
+Example of the status page configuration is the following (status service is using 8080 port):
+
+```
+server {
+    listen 80;
+    server_name builds.example.com;
+
+    location / {
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarder-Proto $scheme;
+
+        proxy_pass http://127.0.0.1:8080;
+    }
+}
+```
+
+## Docker image
+
+We provide official images which can be found under `arcan1s/ahriman` repository. Docker image is being updated on each master commit as well as on each version. If you would like to use last (probably unstable build) you can use `latest` tag; otherwise you can use any version tag available. 
+
+The default action (in case if no arguments provided) is `repo-update`. Basically the idea is to run container, e.g.:
+
+```shell
+docker run --privileged -v /path/to/local/repo:/var/lib/ahriman arcan1s/ahriman:latest
+```
+
+`--privileged` flag is required to make mount possible inside container. In addition, you can pass own configuration overrides by using the same `-v` flag, e.g.:
+
+```shell
+docker run -v /path/to/local/repo:/var/lib/ahriman -v /etc/ahriman.ini:/etc/ahriman.ini.d/10-overrides.ini arcan1s/ahriman:latest
+```
+
+By default, it runs `repo-update`, but it can be overwritten to any other command you would like to, e.g.:
+
+```shell
+docker run arcan1s/ahriman:latest package-add ahriman --now
+```
+
+For more details please refer to docker FAQ.
+
+### Environment variables
+
+The following environment variables are supported:
+
+* `AHRIMAN_ARCHITECTURE` - architecture of the repository, default is `x86_64`.
+* `AHRIMAN_DEBUG` - if set all commands will be logged to console.
+* `AHRIMAN_FORCE_ROOT` - force run ahriman as root instead of guessing by subcommand.
+* `AHRIMAN_HOST` - host for the web interface, default is `0.0.0.0`.
+* `AHRIMAN_OUTPUT` - controls logging handler, e.g. `syslog`, `console`. The name must be found in logging configuration. Note that if `syslog` (the default) handler is used you will need to mount `/dev/log` inside container because it is not available there.
+* `AHRIMAN_PACKAGER` - packager name from which packages will be built, default is `ahriman bot <ahriman@example.com>`.
+* `AHRIMAN_PORT` - HTTP server port if any, default is empty.
+* `AHRIMAN_REPOSITORY` - repository name, default is `aur-clone`.
+* `AHRIMAN_REPOSITORY_ROOT` - repository root. Because of filesystem rights it is required to override default repository root. By default, it uses `ahriman` directory inside ahriman's home, which can be passed as mount volume.
+* `AHRIMAN_USER` - ahriman user, usually must not be overwritten, default is `ahriman`. 
+
+You can pass any of these variables by using `-e` argument, e.g.:
+
+```shell
+docker run -e AHRIMAN_PORT=8080 arcan1s/ahriman:latest
+```
+
+### Working with web service
+
+Well for that you would need to have web container instance running forever; it can be achieved by the following command:
+
+```shell
+docker run -p 8080:8080 -e AHRIMAN_PORT=8080 -v /path/to/local/repo:/var/lib/ahriman arcan1s/ahriman:latest
+```
+
+Note about `AHRIMAN_PORT` environment variable which is required in order to enable web service. An additional port bind by `-p 8080:8080` is required to pass docker port outside of container.
+
+For every next container run use arguments `-e AHRIMAN_PORT=8080 --net=host`, e.g.:
+
+```shell
+docker run --privileged -e AHRIMAN_PORT=8080 --net=host -v /path/to/local/repo:/var/lib/ahriman arcan1s/ahriman:latest
+```
+
+## Remote synchronization
+
+### Wait I would like to use the repository from another server
+
+There are several choices:
+
+1. Easy and cheap, just share your local files through the internet, e.g. for `nginx`:
+   
+    ```
+    server {
+        location /x86_64 {
+            root /var/lib/ahriman/repository/x86_64;
+            autoindex on;
+        }
+    }
+    ```
+   
+2. You can also upload your packages using `rsync` to any available server. In order to use it you would need to configure ahriman first:
+    
+    ```ini
+    [upload]
+    target = rsync
+    
+    [rsync]
+    remote = 192.168.0.1:/srv/repo
+    ```
+   
+    After that just add `/srv/repo` to the `pacman.conf` as usual. You can also upload to S3 (e.g. `Server = https://s3.eu-central-1.amazonaws.com/repository/x86_64`) or to Github (e.g. `Server = https://github.com/ahriman/repository/releases/download/x86_64`).
+
+### How do I configure S3?
+
+1. Install dependencies:
+
+   ```shell
+   pacman -S python-boto3
+   ```
+
+3. Create a bucket.
+4. Create user with write access to the bucket:
+
+    ```
+    {
+        "Version": "2012-10-17",
+        "Statement": [
+            {
+                "Sid": "ListObjectsInBucket",
+                "Effect": "Allow",
+                "Action": [
+                    "s3:ListBucket"
+                ],
+                "Resource": [
+                    "arn:aws:s3:::repository"
+                ]
+            },
+            {
+                "Sid": "AllObjectActions",
+                "Effect": "Allow",
+                "Action": "s3:*Object",
+                "Resource": [
+                    "arn:aws:s3:::repository/*"
+                ]
+            }
+        ]
+    }
+    ```
+
+5. Create an API key for the user and store it.
+6. Configure the service as following:
+
+    ```ini
+    [upload]
+    target = s3
+
+    [s3]
+    access_key = ...
+    bucket = repository
+    region = eu-central-1
+    secret_key = ...
+    ```
+   
+### How do I configure Github?
+
+1. Create a repository.
+2. [Create API key](https://github.com/settings/tokens) with scope `public_repo`.
+3. Configure the service as following:
+
+    ```ini
+    [upload]
+    target = github
+
+    [github]
+    owner = ahriman
+    password = ...
+    repository = repository
+    username = ahriman
+    ```
+
+## Reporting
+
+### I would like to get report to email
+
+1. Install dependencies:
+
+   ```shell
+   yay -S python-jinja
+   ```
+   
+2. Configure the service:
+
+   ```ini
+   [report]
+   target = email
+   
+   [email]
+   host = smtp.example.com
+   link_path = http://example.com/x86_64
+   password = ...
+   port = 465
+   receivers = me@example.com
+   sender = me@example.com
+   user = me@example.com
+   ```
+   
+### I'm using synchronization to S3 and would like to generate index page
+
+1. Install dependencies:
+
+   ```shell
+   yay -S python-jinja
+   ```
+   
+2. Configure the service:
+   
+   ```ini
+   [report]
+   target = html
+   
+   [html]
+   path = /var/lib/ahriman/repository/x86_64/index.html
+   link_path = http://example.com/x86_64
+   ```
+   
+After these steps `index.html` file will be automatically synced to S3
+
+## Web service
+
+### Readme mentions web interface, how do I use it?
+
+1. Install dependencies:
+
+   ```shell
+   yay -S python-aiohttp python-aiohttp-jinja2
+   ```
+
+2. Configure service:
+
+   ```ini
+   [web]
+   port = 8080
+   ```
+
+3. Start the web service `systemctl enable --now ahriman-web@x86_64`.
+
+### I would like to limit user access to the status page
+
+1. Install dependencies 😊:
+   
+   ```shell
+   yay -S python-aiohttp-security python-aiohttp-session python-cryptography
+   ```
+
+2. Configure the service to enable authorization:
+
+   ```ini
+   [auth]
+   target = configuration
+   ```
+   
+3. Create user for the service:
+
+   ```shell
+   sudo -u ahriman ahriman user-add --as-service -r write api
+   ```
+   
+   This command will ask for the password, just type it in stdin; _do not_ leave the field blank, user will not be able to authorize.
+
+4. Create end-user `sudo -u ahriman ahriman user-add -r write my-first-user` with password.
+5. Restart web service `systemctl restart ahriman-web@x86_64`.
+
+### I would like to use OAuth
+
+1. Create OAuth web application, download its `client_id` and `client_secret`.
+2. Guess what? Install dependencies:
+
+   ```shell
+   yay -S python-aiohttp-security python-aiohttp-session python-cryptography python-aioauth-client
+   ```
+   
+3. Configure the service:
+
+   ```ini
+   [auth]
+   target = oauth
+   client_id = ...
+   client_secret = ...
+   
+   [web]
+   address = https://example.com
+   ```
+   
+   Configure `oauth_provider` and `oauth_scopes` in case if you would like to use different from Google provider. Scope must grant access to user email. `web.address` is required to make callback URL available from internet.
+
+4. Create service user:
+
+   ```shell
+   sudo -u ahriman ahriman user-add --as-service -r write api
+   ```
+
+5. Create end-user `sudo -u ahriman ahriman user-add -r write my-first-user`. When it will ask for the password leave it blank.
+6. Restart web service `systemctl restart ahriman-web@x86_64`.
+
+## Other topics
+
+### How does it differ from %another-manager%?
+
+Short answer - I do not know.
+
+#### [archrepo2](https://github.com/lilydjwg/archrepo2)
+
+Don't know, haven't tried it. But it lacks of documentation at least.
+
+* Web interface.
+* No synchronization and reporting.
+* `archrepo2` actively uses direct shell calls and `yaourt` components.
+* It has constantly running process instead of timer process (it is not pro or con).
+
+#### [repoctl](https://github.com/cassava/repoctl)
+
+* Web interface.
+* No reporting.
+* Local packages and patches support.
+* Some actions are not fully automated (e.g. package update still requires manual intervention for the build itself). 
+* `repoctl` has better AUR interaction features. With colors!
+* `repoctl` has much easier configuration and even completion.
+* `repoctl` is able to store old packages.
+* Ability to host repository from same command vs external services (e.g. nginx) in `ahriman`.
+
+#### [repo-scripts](https://github.com/arcan1s/repo-scripts)
+
+Though originally I've created ahriman by trying to improve the project, it still lacks a lot of features:
+
+* Web interface.
+* Better reporting with template support.
+* Synchronization features (there was only `rsync` based).
+* Local packages and patches support.
+* No dependency management.
+* And so on.
+
+`repo-scripts` also have bad architecture and bad quality code and uses out-of-dated `yaourt` and `package-query`.
+
+### I would like to check service logs
+
+By default, the service writes logs to `/dev/log` which can be accessed by using `journalctl` command (logs are written to the journal of the user under which command is run).
+
+You can also edit configuration and forward logs to `stderr`, just change `handlers` value, e.g.:
+
+```shell
+sed -i 's/handlers = syslog_handler/handlers = console_handler/g' /etc/ahriman.ini.d/logging.ini
+```
+
+You can even configure logging as you wish, but kindly refer to python `logging` module configuration.
+
+### Html customization
+
+It is possible to customize html templates. In order to do so, create files somewhere (refer to Jinja2 documentation and the service source code for available parameters) and put `template_path` to configuration pointing to this directory.
+
+### I did not find my question
+
+[Create an issue](https://github.com/arcan1s/ahriman/issues) with type **Question**.

docs/setup.md

@@ -2,59 +2,65 @@
 
 1. Install package as usual.
 2. Change settings if required, see [configuration reference](configuration.md) for more details.
-3. Create `/var/lib/ahriman/.makepkg.conf` with `makepkg.conf` overrides if required (at least you might want to set `PACKAGER`):
+3. TL;DR
 
-    ```shell
-    echo 'PACKAGER="John Doe <john@doe.com>"' | sudo -u ahriman tee -a /var/lib/ahriman/.makepkg.conf
-    ```
+   ```shell
+   sudo ahriman -a x86_64 repo-setup ...
+   ```
+   
+   `repo-setup` literally does the following steps:
 
-4. Configure build tools (it is required for correct dependency management system):
+   1. Create `/var/lib/ahriman/.makepkg.conf` with `makepkg.conf` overrides if required (at least you might want to set `PACKAGER`):
 
-    1. Create build command, e.g. `ln -s /usr/bin/archbuild /usr/local/bin/ahriman-x86_64-build` (you can choose any name for command, basically it should be `{name}-{arch}-build`).
-    2. Create configuration file, e.g. `cp /usr/share/devtools/pacman-{extra,ahriman}.conf` (same as previous `pacman-{name}.conf`).
-    3. Change configuration file, add your own repository, add multilib repository etc;
-    4. Set `build_command` option to point to your command.
-    5. Configure `/etc/sudoers.d/ahriman` to allow running command without a password.
+       ```shell
+       echo 'PACKAGER="John Doe <john@doe.com>"' | sudo -u ahriman tee -a /var/lib/ahriman/.makepkg.conf
+       ```
 
-    ```shell
-    ln -s /usr/bin/archbuild /usr/local/bin/ahriman-x86_64-build
-    cp /usr/share/devtools/pacman-{extra,ahriman}.conf
+   2. Configure build tools (it is required for correct dependency management system):
 
-    echo '[multilib]' | tee -a /usr/share/devtools/pacman-ahriman.conf
-    echo 'Include = /etc/pacman.d/mirrorlist' | tee -a /usr/share/devtools/pacman-ahriman.conf
+       1. Create build command, e.g. `ln -s /usr/bin/archbuild /usr/local/bin/ahriman-x86_64-build` (you can choose any name for command, basically it should be `{name}-{arch}-build`).
+       2. Create configuration file, e.g. `cp /usr/share/devtools/pacman-{extra,ahriman}.conf` (same as previous `pacman-{name}.conf`).
+       3. Change configuration file, add your own repository, add multilib repository etc;
+       4. Set `build_command` option to point to your command.
+       5. Configure `/etc/sudoers.d/ahriman` to allow running command without a password.
 
-    echo '[aur-clone]' | tee -a /usr/share/devtools/pacman-ahriman.conf
-    echo 'SigLevel = Optional TrustAll' | tee -a /usr/share/devtools/pacman-ahriman.conf
-    echo 'Server = file:///var/lib/ahriman/repository/$arch' | tee -a /usr/share/devtools/pacman-ahriman.conf
+       ```shell
+       ln -s /usr/bin/archbuild /usr/local/bin/ahriman-x86_64-build
+       cp /usr/share/devtools/pacman-{extra,ahriman}.conf
 
-    echo '[build]' | tee -a /etc/ahriman.ini.d/build.ini
-    echo 'build_command = ahriman-x86_64-build' | tee -a /etc/ahriman.ini.d/build.ini
+       echo '[multilib]' | tee -a /usr/share/devtools/pacman-ahriman.conf
+       echo 'Include = /etc/pacman.d/mirrorlist' | tee -a /usr/share/devtools/pacman-ahriman.conf
 
-    echo 'Cmnd_Alias CARCHBUILD_CMD = /usr/local/bin/ahriman-x86_64-build *' | tee -a /etc/sudoers.d/ahriman
-    echo 'ahriman ALL=(ALL) NOPASSWD: CARCHBUILD_CMD' | tee -a /etc/sudoers.d/ahriman
-    chmod 400 /etc/sudoers.d/ahriman
-    ```
+       echo '[aur-clone]' | tee -a /usr/share/devtools/pacman-ahriman.conf
+       echo 'SigLevel = Optional TrustAll' | tee -a /usr/share/devtools/pacman-ahriman.conf
+       echo 'Server = file:///var/lib/ahriman/repository/$arch' | tee -a /usr/share/devtools/pacman-ahriman.conf
 
-5. Start and enable `ahriman@.timer` via `systemctl`:
+       echo '[build]' | tee -a /etc/ahriman.ini.d/build.ini
+       echo 'build_command = ahriman-x86_64-build' | tee -a /etc/ahriman.ini.d/build.ini
+
+       echo 'Cmnd_Alias CARCHBUILD_CMD = /usr/local/bin/ahriman-x86_64-build *' | tee -a /etc/sudoers.d/ahriman
+       echo 'ahriman ALL=(ALL) NOPASSWD: CARCHBUILD_CMD' | tee -a /etc/sudoers.d/ahriman
+       chmod 400 /etc/sudoers.d/ahriman
+       ```
+
+4. Start and enable `ahriman@.timer` via `systemctl`:
 
     ```shell
     systemctl enable --now ahriman@x86_64.timer
     ```
 
-6. Start and enable status page:
+5. Start and enable status page:
 
     ```shell
     systemctl enable --now ahriman-web@x86_64
     ```
 
-7. Add packages by using `ahriman add {package}` command:
+6. Add packages by using `ahriman package-add {package}` command:
 
     ```shell
-    sudo -u ahriman ahriman -a x86_64 add yay --now
+    sudo -u ahriman ahriman -a x86_64 package-add ahriman --now
     ```
 
-Note that initial service configuration can be done by running `ahriman setup` with specific arguments.
-
 ## User creation
 
-`create-user` subcommand is recommended for new user creation.
+`user-add` subcommand is recommended for new user creation.

package/archlinux/PKGBUILD

@@ -1,17 +1,16 @@
 # Maintainer: Evgeniy Alekseev
 
 pkgname='ahriman'
-pkgver=1.4.1
+pkgver=2.0.0rc2
 pkgrel=1
 pkgdesc="ArcH Linux ReposItory MANager"
 arch=('any')
 url="https://github.com/arcan1s/ahriman"
 license=('GPL3')
-depends=('devtools' 'git' 'pyalpm' 'python-aur' 'python-passlib' 'python-srcinfo')
-makedepends=('python-pip')
+depends=('devtools' 'git' 'pyalpm' 'python-inflection' 'python-passlib' 'python-requests' 'python-srcinfo')
+makedepends=('python-build' 'python-installer' 'python-wheel')
 optdepends=('breezy: -bzr packages support'
             'darcs: -darcs packages support'
-            'gnupg: package and repository sign'
             'mercurial: -hg packages support'
             'python-aioauth-client: web server with OAuth2 authorization'
             'python-aiohttp: web server'
@@ -33,18 +32,23 @@ backup=('etc/ahriman.ini'
 build() {
   cd "$pkgname"
 
-  python setup.py build
+  python -m build --wheel --no-isolation
 }
 
 package() {
   cd "$pkgname"
 
-  python setup.py install --root="$pkgdir"
+  python -m installer --destdir="$pkgdir" dist/*.whl
+
+  # python-installer actually thinks that you cannot just copy files to root
+  # thus we need to copy them manually
+  install -Dm644 "$pkgdir/usr/share/$pkgname/settings/ahriman.ini" "$pkgdir/etc/ahriman.ini"
+  install -Dm644 "$pkgdir/usr/share/$pkgname/settings/ahriman.ini.d/logging.ini" "$pkgdir/etc/ahriman.ini.d/logging.ini"
 
   install -Dm644 "$srcdir/$pkgname.sysusers" "$pkgdir/usr/lib/sysusers.d/$pkgname.conf"
   install -Dm644 "$srcdir/$pkgname.tmpfiles" "$pkgdir/usr/lib/tmpfiles.d/$pkgname.conf"
 }
 
-sha512sums=('6ab741bfb42f92ab00d1b6ecfc44426c00e5c433486e014efbdb585715d9a12dbbafc280e5a9f85b941c8681b13a9dad41327a3e3c44a9683ae30c1d6f017f50'
-            '13718afec2c6786a18f0b223ef8e58dccf0688bca4cdbe203f14071f5031ed20120eb0ce38b52c76cfd6e8b6581a9c9eaa2743eb11abbaca637451a84c33f075'
-            '55b20f6da3d66e7bbf2add5d95a3b60632df121717d25a993e56e737d14f51fe063eb6f1b38bd81cc32e05db01c0c1d80aaa720c45cde87f238d8b46cdb8cbc4')
+sha512sums=('112b0d8aac68e5330bbdd2b86a59c8a9af8ab7a7c636489623c8460bb90f1318585851edd2a97a8ce20e2d2ad93b847b522685df707c190aa39d23ab908fa8ef'
+            '53d37efec812afebf86281716259f9ea78a307b83897166c72777251c3eebcb587ecee375d907514781fb2a5c808cbb24ef9f3f244f12740155d0603bf213131'
+            '62b2eccc352d33853ef243c9cddd63663014aa97b87242f1b5bc5099a7dbd69ff3821f24ffc58e1b7f2387bd4e9e9712cc4c67f661b1724ad99cdf09b3717794')

package/archlinux/ahriman.tmpfiles

@@ -1 +1,2 @@
+d /var/lib/ahriman 0755 ahriman ahriman
 d /var/log/ahriman 0755 ahriman ahriman

package/share/ahriman/settings/ahriman.ini

@@ -1,6 +1,7 @@
 [settings]
-include = /etc/ahriman.ini.d
-logging = /etc/ahriman.ini.d/logging.ini
+include = ahriman.ini.d
+logging = ahriman.ini.d/logging.ini
+database = /var/lib/ahriman/ahriman.db
 
 [alpm]
 aur_url = https://aur.archlinux.org
@@ -20,7 +21,7 @@ archbuild_flags =
 build_command = extra-x86_64-build
 ignore_packages =
 makechrootpkg_flags =
-makepkg_flags =
+makepkg_flags = --nocolor
 
 [repository]
 name = aur-clone
@@ -30,16 +31,19 @@ root = /var/lib/ahriman
 target =
 
 [report]
-target =
+target = console
+
+[console]
+use_utf = yes
 
 [email]
-full_template_path = /usr/share/ahriman/repo-index.jinja2
+full_template_path = /usr/share/ahriman/templates/repo-index.jinja2
 no_empty_report = yes
-template_path = /usr/share/ahriman/email-index.jinja2
+template_path = /usr/share/ahriman/templates/email-index.jinja2
 ssl = disabled
 
 [html]
-template_path = /usr/share/ahriman/repo-index.jinja2
+template_path = /usr/share/ahriman/templates/repo-index.jinja2
 
 [upload]
 target =
@@ -55,5 +59,5 @@ debug = no
 debug_check_host = no
 debug_allowed_hosts =
 host = 127.0.0.1
-static_path = /usr/share/ahriman/static
-templates = /usr/share/ahriman
+static_path = /usr/share/ahriman/templates/static
+templates = /usr/share/ahriman/templates

package/share/ahriman/settings/ahriman.ini.d/logging.ini

@@ -1,5 +1,5 @@
 [loggers]
-keys = root,builder,build_details,http
+keys = root,build_details,database,http,stderr,boto3,botocore,nose,s3transfer
 
 [handlers]
 keys = console_handler,syslog_handler
@@ -20,11 +20,11 @@ formatter = syslog_format
 args = ("/dev/log",)
 
 [formatter_generic_format]
-format = [%(levelname)s %(asctime)s] [%(filename)s:%(lineno)d] [%(funcName)s]: %(message)s
+format = [%(levelname)s %(asctime)s] [%(filename)s:%(lineno)d %(funcName)s]: %(message)s
 datefmt =
 
 [formatter_syslog_format]
-format = [%(levelname)s] [%(filename)s:%(lineno)d] [%(funcName)s]: %(message)s
+format = [%(levelname)s] [%(name)s] [%(filename)s:%(lineno)d] [%(funcName)s]: %(message)s
 datefmt =
 
 [logger_root]
@@ -32,20 +32,49 @@ level = DEBUG
 handlers = syslog_handler
 qualname = root
 
-[logger_builder]
-level = DEBUG
-handlers = syslog_handler
-qualname = builder
-propagate = 0
-
 [logger_build_details]
 level = DEBUG
 handlers = syslog_handler
 qualname = build_details
 propagate = 0
 
+[logger_database]
+level = DEBUG
+handlers = syslog_handler
+qualname = database
+propagate = 0
+
 [logger_http]
 level = DEBUG
 handlers = syslog_handler
 qualname = http
 propagate = 0
+
+[logger_stderr]
+level = DEBUG
+handlers = console_handler
+qualname = stderr
+
+[logger_boto3]
+level = INFO
+handlers = syslog_handler
+qualname = boto3
+propagate = 0
+
+[logger_botocore]
+level = INFO
+handlers = syslog_handler
+qualname = botocore
+propagate = 0
+
+[logger_nose]
+level = INFO
+handlers = syslog_handler
+qualname = nose
+propagate = 0
+
+[logger_s3transfer]
+level = INFO
+handlers = syslog_handler
+qualname = s3transfer
+propagate = 0

package/share/ahriman/templates/build-status.jinja2

@@ -16,7 +16,7 @@
             <h1>ahriman
                 {% if auth.authenticated %}
                     <img src="https://img.shields.io/badge/version-{{ version }}-informational" alt="{{ version }}">
-                    <img src="https://img.shields.io/badge/repository-{{ repository }}-informational" alt="{{ repository }}">
+                    <img src="https://img.shields.io/badge/repository-{{ repository | replace("-", "--") }}-informational" alt="{{ repository }}">
                     <img src="https://img.shields.io/badge/architecture-{{ architecture }}-informational" alt="{{ architecture }}">
                     <img src="https://img.shields.io/badge/service%20status-{{ service.status }}-{{ service.status_color }}" alt="{{ service.status }}" title="{{ service.timestamp }}">
                 {% endif %}
@@ -27,13 +27,13 @@
             <div id="toolbar">
                 {% if not auth.enabled or auth.username is not none %}
                     <button id="add" class="btn btn-primary" data-bs-toggle="modal" data-bs-target="#addForm">
-                        <i class="fa fa-plus"></i> Add
+                        <i class="fa fa-plus"></i> add
                     </button>
                     <button id="update" class="btn btn-secondary" onclick="updatePackages()" disabled>
-                        <i class="fa fa-play"></i> Update
+                        <i class="fa fa-play"></i> update
                     </button>
                     <button id="remove" class="btn btn-danger" onclick="removePackages()" disabled>
-                        <i class="fa fa-trash"></i> Remove
+                        <i class="fa fa-trash"></i> remove
                     </button>
                 {% endif %}
             </div>

package/share/ahriman/templates/build-status/login-modal.jinja2

@@ -3,25 +3,25 @@
         <div class="modal-content">
             <form action="/user-api/v1/login" method="post">
                 <div class="modal-header">
-                    <h4 class="modal-title">Login</h4>
+                    <h4 class="modal-title">login</h4>
                     <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="close"></button>
                 </div>
                 <div class="modal-body">
                     <div class="form-group row">
-                        <label for="username" class="col-sm-2 col-form-label">Username</label>
+                        <label for="username" class="col-sm-2 col-form-label">username</label>
                         <div class="col-sm-10">
                             <input id="username" type="text" class="form-control" placeholder="enter username" name="username" required>
                         </div>
                     </div>
                     <div class="form-group row">
-                        <label for="password" class="col-sm-2 col-form-label">Password</label>
+                        <label for="password" class="col-sm-2 col-form-label">password</label>
                         <div class="col-sm-10">
                             <input id="password" type="password" class="form-control" placeholder="enter password" name="password" required>
                         </div>
                     </div>
                 </div>
                 <div class="modal-footer">
-                    <button class="btn btn-primary">Login</button>
+                    <button class="btn btn-primary">login</button>
                 </div>
             </form>
         </div>

package/share/ahriman/templates/build-status/package-actions-modals.jinja2

@@ -2,12 +2,12 @@
     <div class="modal-dialog" role="document">
         <div class="modal-content">
             <div class="modal-header">
-                <h4 class="modal-title">Add new packages</h4>
+                <h4 class="modal-title">add new packages</h4>
                 <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="close"></button>
             </div>
             <div class="modal-body">
                 <div class="form-group row">
-                    <label for="package" class="col-sm-2 col-form-label">Package</label>
+                    <label for="package" class="col-sm-2 col-form-label">package</label>
                     <div class="col-sm-10">
                         <input id="package" type="text" list="knownPackages" class="form-control" placeholder="AUR package" name="package" required>
                         <datalist id="knownPackages"></datalist>
@@ -15,9 +15,9 @@
                 </div>
             </div>
             <div class="modal-footer">
-                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">Close</button>
-                <button type="button" class="btn btn-success" data-bs-dismiss="modal" onclick="requestPackages()">Request</button>
-                <button type="button" class="btn btn-primary" data-bs-dismiss="modal" onclick="addPackages()">Add</button>
+                <button type="button" class="btn btn-secondary" data-bs-dismiss="modal">close</button>
+                <button type="button" class="btn btn-success" data-bs-dismiss="modal" onclick="requestPackages()">request</button>
+                <button type="button" class="btn btn-primary" data-bs-dismiss="modal" onclick="addPackages()">add</button>
             </div>
         </div>
     </div>
@@ -27,7 +27,7 @@
     <div class="modal-dialog" role="document">
         <div class="modal-content">
             <div class="modal-header bg-danger">
-                <h4 class="modal-title">Failed</h4>
+                <h4 class="modal-title">failed</h4>
                 <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="close"></button>
             </div>
             <div class="modal-body">
@@ -35,7 +35,7 @@
                 <p id="errorDetails"></p>
             </div>
             <div class="modal-footer">
-                <button type="button" class="btn btn-primary" data-bs-dismiss="modal">Close</button>
+                <button type="button" class="btn btn-primary" data-bs-dismiss="modal">close</button>
             </div>
         </div>
     </div>
@@ -45,7 +45,7 @@
     <div class="modal-dialog" role="document">
         <div class="modal-content">
             <div class="modal-header bg-success">
-                <h4 class="modal-title">Success</h4>
+                <h4 class="modal-title">success</h4>
                 <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="close"></button>
             </div>
             <div class="modal-body">
@@ -53,7 +53,7 @@
                 <ul id="successDetails"></ul>
             </div>
             <div class="modal-footer">
-                <button type="button" class="btn btn-primary" data-bs-dismiss="modal">Close</button>
+                <button type="button" class="btn btn-primary" data-bs-dismiss="modal">close</button>
             </div>
         </div>
     </div>

package/share/ahriman/templates/repo-index.jinja2

@@ -82,7 +82,7 @@ SigLevel = Database{% if has_repo_signed %}Required{% else %}Never{% endif %} Pa
             <footer class="d-flex flex-wrap justify-content-between align-items-center border-top">
                 <ul class="nav">
                     {% if homepage is not none %}
-                        <li><a class="nav-link" href="{{ homepage }}" title="homepage">Homepage</a></li>
+                        <li><a class="nav-link" href="{{ homepage }}" title="homepage">homepage</a></li>
                     {% endif %}
                 </ul>
             </footer>

package/share/ahriman/templates/utils/bootstrap-scripts.jinja2

@@ -10,3 +10,14 @@
 <script src="https://unpkg.com/bootstrap-table@1.18.3/dist/extensions/export/bootstrap-table-export.min.js"></script>
 
 <script src="https://unpkg.com/bootstrap-table@1.18.3/dist/extensions/resizable/bootstrap-table-resizable.js"></script>
+
+<script>
+    $("#packages").bootstrapTable({
+        formatClearSearch: function () {
+            return "Clear search";
+        },
+        formatSearch: function () {
+            return "search";
+        }
+    })
+</script>

setup.cfg

@@ -1,5 +0,0 @@
-[aliases]
-test = pytest
-
-[tool:pytest]
-addopts = --cov=ahriman --cov-report term-missing:skip-covered --pspec

setup.py

@@ -17,7 +17,7 @@ setup(
 
     description="ArcH Linux ReposItory MANager",
 
-    author="arcanis",
+    author="ahriman team",
     author_email="",
     url="https://github.com/arcan1s/ahriman",
 
@@ -29,14 +29,13 @@ setup(
     dependency_links=[
     ],
     install_requires=[
-        "aur",
+        "inflection",
         "passlib",
         "pyalpm",
         "requests",
         "srcinfo",
     ],
     setup_requires=[
-        "pytest-runner",
     ],
     tests_require=[
         "pytest",
@@ -44,7 +43,7 @@ setup(
         "pytest-cov",
         "pytest-helpers-namespace",
         "pytest-mock",
-        "pytest-pspec",
+        "pytest-spec",
         "pytest-resource-path",
     ],
 
@@ -53,33 +52,33 @@ setup(
         "package/bin/ahriman",
     ],
     data_files=[
-        ("/etc", [
-            "package/etc/ahriman.ini",
+        ("share/ahriman/settings", [
+            "package/share/ahriman/settings/ahriman.ini",
         ]),
-        ("/etc/ahriman.ini.d", [
-            "package/etc/ahriman.ini.d/logging.ini",
+        ("share/ahriman/settings/ahriman.ini.d", [
+            "package/share/ahriman/settings/ahriman.ini.d/logging.ini",
         ]),
         ("lib/systemd/system", [
             "package/lib/systemd/system/ahriman@.service",
             "package/lib/systemd/system/ahriman@.timer",
             "package/lib/systemd/system/ahriman-web@.service",
         ]),
-        ("share/ahriman", [
-            "package/share/ahriman/build-status.jinja2",
-            "package/share/ahriman/email-index.jinja2",
-            "package/share/ahriman/repo-index.jinja2",
+        ("share/ahriman/templates", [
+            "package/share/ahriman/templates/build-status.jinja2",
+            "package/share/ahriman/templates/email-index.jinja2",
+            "package/share/ahriman/templates/repo-index.jinja2",
         ]),
-        ("share/ahriman/build-status", [
-            "package/share/ahriman/build-status/login-modal.jinja2",
-            "package/share/ahriman/build-status/package-actions-modals.jinja2",
-            "package/share/ahriman/build-status/package-actions-script.jinja2",
+        ("share/ahriman/templates/build-status", [
+            "package/share/ahriman/templates/build-status/login-modal.jinja2",
+            "package/share/ahriman/templates/build-status/package-actions-modals.jinja2",
+            "package/share/ahriman/templates/build-status/package-actions-script.jinja2",
         ]),
-        ("share/ahriman/static", [
-            "package/share/ahriman/static/favicon.ico",
+        ("share/ahriman/templates/static", [
+            "package/share/ahriman/templates/static/favicon.ico",
         ]),
-        ("share/ahriman/utils", [
-            "package/share/ahriman/utils/bootstrap-scripts.jinja2",
-            "package/share/ahriman/utils/style.jinja2",
+        ("share/ahriman/templates/utils", [
+            "package/share/ahriman/templates/utils/bootstrap-scripts.jinja2",
+            "package/share/ahriman/templates/utils/style.jinja2",
         ]),
         ("share/man/man1", [
             "docs/ahriman.1",
@@ -96,14 +95,14 @@ setup(
         "s3": [
             "boto3",
         ],
-        "test": [
+        "tests": [
             "pytest",
             "pytest-aiohttp",
             "pytest-cov",
             "pytest-helpers-namespace",
             "pytest-mock",
-            "pytest-pspec",
             "pytest-resource-path",
+            "pytest-spec",
         ],
         "web": [
             "Jinja2",

src/ahriman/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/application/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/application/ahriman.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -22,17 +22,31 @@ import sys
 import tempfile
 
 from pathlib import Path
+from typing import TypeVar
 
 from ahriman import version
 from ahriman.application import handlers
+from ahriman.models.action import Action
 from ahriman.models.build_status import BuildStatusEnum
 from ahriman.models.package_source import PackageSource
 from ahriman.models.sign_settings import SignSettings
 from ahriman.models.user_access import UserAccess
 
 
-# pylint thinks it is bad idea, but get the fuck off
-SubParserAction = argparse._SubParsersAction  # pylint: disable=protected-access
+# this workaround is for several things
+# firstly python devs don't think that is it error and asking you for workarounds https://bugs.python.org/issue41592
+# secondly linters don't like when you are importing private members
+# thirdly new mypy doesn't like _SubParsersAction and thinks it is a template
+SubParserAction = TypeVar("SubParserAction", bound="argparse._SubParsersAction[argparse.ArgumentParser]")
+
+
+def _formatter(prog: str) -> argparse.HelpFormatter:
+    """
+    formatter for the help message
+    :param prog: application name
+    :return: formatter used by default
+    """
+    return argparse.ArgumentDefaultsHelpFormatter(prog, width=120)
 
 
 def _parser() -> argparse.ArgumentParser:
@@ -41,119 +55,99 @@ def _parser() -> argparse.ArgumentParser:
     :return: command line parser for the application
     """
     parser = argparse.ArgumentParser(prog="ahriman", description="ArcH Linux ReposItory MANager",
-                                     formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                                     epilog="Argument list can also be read from file by using @ prefix.",
+                                     fromfile_prefix_chars="@", formatter_class=_formatter)
     parser.add_argument("-a", "--architecture", help="target architectures (can be used multiple times)",
                         action="append")
     parser.add_argument("-c", "--configuration", help="configuration path", type=Path, default=Path("/etc/ahriman.ini"))
     parser.add_argument("--force", help="force run, remove file lock", action="store_true")
-    parser.add_argument(
-        "-l",
-        "--lock",
-        help="lock file",
-        type=Path,
-        default=Path(tempfile.gettempdir()) / "ahriman.lock")
-    parser.add_argument("--no-log", help="redirect all log messages to stderr", action="store_true")
+    parser.add_argument("-l", "--lock", help="lock file", type=Path,
+                        default=Path(tempfile.gettempdir()) / "ahriman.lock")
     parser.add_argument("--no-report", help="force disable reporting to web service", action="store_true")
-    parser.add_argument("--unsafe", help="allow to run ahriman as non-ahriman user", action="store_true")
+    parser.add_argument("-q", "--quiet", help="force disable any logging", action="store_true")
+    parser.add_argument("--unsafe", help="allow to run ahriman as non-ahriman user. Some actions might be unavailable",
+                        action="store_true")
     parser.add_argument("-v", "--version", action="version", version=version.__version__)
 
     subparsers = parser.add_subparsers(title="command", help="command to run", dest="command", required=True)
 
-    _set_add_parser(subparsers)
-    _set_check_parser(subparsers)
-    _set_clean_parser(subparsers)
-    _set_config_parser(subparsers)
-    _set_init_parser(subparsers)
+    _set_aur_search_parser(subparsers)
+    _set_help_parser(subparsers)
+    _set_help_commands_unsafe_parser(subparsers)
     _set_key_import_parser(subparsers)
-    _set_rebuild_parser(subparsers)
-    _set_remove_parser(subparsers)
-    _set_remove_unknown_parser(subparsers)
-    _set_report_parser(subparsers)
-    _set_search_parser(subparsers)
-    _set_setup_parser(subparsers)
-    _set_sign_parser(subparsers)
-    _set_status_parser(subparsers)
-    _set_status_update_parser(subparsers)
-    _set_sync_parser(subparsers)
-    _set_update_parser(subparsers)
-    _set_user_parser(subparsers)
+    _set_package_add_parser(subparsers)
+    _set_package_remove_parser(subparsers)
+    _set_package_status_parser(subparsers)
+    _set_package_status_remove_parser(subparsers)
+    _set_package_status_update_parser(subparsers)
+    _set_patch_add_parser(subparsers)
+    _set_patch_list_parser(subparsers)
+    _set_patch_remove_parser(subparsers)
+    _set_repo_check_parser(subparsers)
+    _set_repo_clean_parser(subparsers)
+    _set_repo_config_parser(subparsers)
+    _set_repo_rebuild_parser(subparsers)
+    _set_repo_remove_unknown_parser(subparsers)
+    _set_repo_report_parser(subparsers)
+    _set_repo_setup_parser(subparsers)
+    _set_repo_sign_parser(subparsers)
+    _set_repo_status_update_parser(subparsers)
+    _set_repo_sync_parser(subparsers)
+    _set_repo_update_parser(subparsers)
+    _set_user_add_parser(subparsers)
+    _set_user_list_parser(subparsers)
+    _set_user_remove_parser(subparsers)
     _set_web_parser(subparsers)
 
     return parser
 
 
-def _set_add_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_aur_search_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for add subcommand
+    add parser for AUR search subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("add", help="add package", description="add package",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument("package", help="package base/name or archive path", nargs="+")
-    parser.add_argument("--now", help="run update function after", action="store_true")
-    parser.add_argument("--source", help="package source", choices=PackageSource, type=PackageSource,
-                        default=PackageSource.Auto)
-    parser.add_argument("--without-dependencies", help="do not add dependencies", action="store_true")
-    parser.set_defaults(handler=handlers.Add)
+    parser = root.add_parser("aur-search", aliases=["search"], help="search for package",
+                             description="search for package in AUR using API", formatter_class=_formatter)
+    parser.add_argument("search", help="search terms, can be specified multiple times, result will match all terms",
+                        nargs="+")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
+    parser.add_argument("-i", "--info", help="show additional package information", action="store_true")
+    parser.add_argument("--sort-by", help="sort field by this field. In case if two packages have the same value of "
+                                          "the specified field, they will be always sorted by name",
+                        default="name", choices=sorted(handlers.Search.SORT_FIELDS))
+    parser.set_defaults(handler=handlers.Search, architecture=[""], lock=None, no_report=True, quiet=True, unsafe=True)
     return parser
 
 
-def _set_check_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_help_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for check subcommand
+    add parser for listing help subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("check", help="check for updates",
-                             description="check for updates. Same as update --dry-run --no-manual",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument("package", help="filter check by package base", nargs="*")
-    parser.add_argument("--no-vcs", help="do not check VCS packages", action="store_true")
-    parser.set_defaults(handler=handlers.Update, no_aur=False, no_manual=True, dry_run=True)
+    parser = root.add_parser("help", help="show help message",
+                             description="show help message for application or command and exit",
+                             formatter_class=_formatter)
+    parser.add_argument("command", help="show help message for specific command", nargs="?")
+    parser.set_defaults(handler=handlers.Help, architecture=[""], lock=None, no_report=True, quiet=True,
+                        unsafe=True, parser=_parser)
     return parser
 
 
-def _set_clean_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_help_commands_unsafe_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for clean subcommand
+    add parser for listing unsafe commands
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("clean", help="clean local caches", description="clear local caches",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument("--no-build", help="do not clear directory with package sources", action="store_true")
-    parser.add_argument("--no-cache", help="do not clear directory with package caches", action="store_true")
-    parser.add_argument("--no-chroot", help="do not clear build chroot", action="store_true")
-    parser.add_argument("--no-manual", help="do not clear directory with manually added packages", action="store_true")
-    parser.add_argument("--no-packages", help="do not clear directory with built packages", action="store_true")
-    parser.set_defaults(handler=handlers.Clean, no_log=True, unsafe=True)
-    return parser
-
-
-def _set_config_parser(root: SubParserAction) -> argparse.ArgumentParser:
-    """
-    add parser for config subcommand
-    :param root: subparsers for the commands
-    :return: created argument parser
-    """
-    parser = root.add_parser("config", help="dump configuration",
-                             description="dump configuration for specified architecture",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.set_defaults(handler=handlers.Dump, lock=None, no_log=True, no_report=True, unsafe=True)
-    return parser
-
-
-def _set_init_parser(root: SubParserAction) -> argparse.ArgumentParser:
-    """
-    add parser for init subcommand
-    :param root: subparsers for the commands
-    :return: created argument parser
-    """
-    parser = root.add_parser("init", help="create repository tree",
-                             description="create empty repository tree. Optional command for auto architecture support",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.set_defaults(handler=handlers.Init, no_report=True)
+    parser = root.add_parser("help-commands-unsafe", help="list unsafe commands",
+                             description="list unsafe commands as defined in default args", formatter_class=_formatter)
+    parser.add_argument("--command", help="instead of showing commands, just test command line for unsafe subcommand "
+                                          "and return 0 in case if command is safe and 1 otherwise")
+    parser.set_defaults(handler=handlers.UnsafeCommands, architecture=[""], lock=None, no_report=True, quiet=True,
+                        unsafe=True, parser=_parser)
     return parser
 
 
@@ -164,88 +158,268 @@ def _set_key_import_parser(root: SubParserAction) -> argparse.ArgumentParser:
     :return: created argument parser
     """
     parser = root.add_parser("key-import", help="import PGP key",
-                             description="import PGP key from public sources to repository user",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                             description="import PGP key from public sources to the repository user",
+                             epilog="By default ahriman runs build process with package sources validation "
+                                    "(in case if signature and keys are available in PKGBUILD). This process will "
+                                    "fail in case if key is not known for build user. This subcommand can be used "
+                                    "in order to import the PGP key to user keychain.",
+                             formatter_class=_formatter)
     parser.add_argument("--key-server", help="key server for key import", default="pgp.mit.edu")
     parser.add_argument("key", help="PGP key to import from public server")
     parser.set_defaults(handler=handlers.KeyImport, architecture=[""], lock=None, no_report=True)
     return parser
 
 
-def _set_rebuild_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_package_add_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for rebuild subcommand
+    add parser for package addition subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("rebuild", help="rebuild repository", description="rebuild whole repository",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument("--depends-on", help="only rebuild packages that depend on specified package", action="append")
-    parser.set_defaults(handler=handlers.Rebuild)
+    parser = root.add_parser("package-add", aliases=["add", "package-update"], help="add package",
+                             description="add existing or new package to the build queue",
+                             epilog="This subcommand should be used for new package addition. It also supports flag "
+                                    "--now in case if you would like to build the package immediately. "
+                                    "You can add new package from one of supported sources: "
+                                    "1) if it is already built package you can specify the path to the archive; "
+                                    "2) you can also add built packages from the directory (e.g. during the migration "
+                                    "from another repository source); "
+                                    "3) it is also possible to add package from local PKGBUILD, but in this case it "
+                                    "will be ignored during the next automatic updates; "
+                                    "4) ahriman supports downloading archives from remote (e.g. HTTP) sources; "
+                                    "5) and finally you can add package from AUR.",
+                             formatter_class=_formatter)
+    parser.add_argument("package", help="package source (base name, path to local files, remote URL)", nargs="+")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
+    parser.add_argument("-n", "--now", help="run update function after", action="store_true")
+    parser.add_argument("-s", "--source", help="explicitly specify the package source for this command",
+                        type=PackageSource, choices=PackageSource, default=PackageSource.Auto)
+    parser.add_argument("--without-dependencies", help="do not add dependencies", action="store_true")
+    parser.set_defaults(handler=handlers.Add)
     return parser
 
 
-def _set_remove_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_package_remove_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for remove subcommand
+    add parser for package removal subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("remove", help="remove package", description="remove package",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("package-remove", aliases=["remove"], help="remove package",
+                             description="remove package from the repository", formatter_class=_formatter)
     parser.add_argument("package", help="package name or base", nargs="+")
     parser.set_defaults(handler=handlers.Remove)
     return parser
 
 
-def _set_remove_unknown_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_package_status_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for package status subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("package-status", aliases=["status"], help="get package status",
+                             description="request status of the package",
+                             epilog="This feature requests package status from the web interface if it is available.",
+                             formatter_class=_formatter)
+    parser.add_argument("package", help="filter status by package base", nargs="*")
+    parser.add_argument("--ahriman", help="get service status itself", action="store_true")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
+    parser.add_argument("-i", "--info", help="show additional package information", action="store_true")
+    parser.add_argument("-s", "--status", help="filter packages by status",
+                        type=BuildStatusEnum, choices=BuildStatusEnum)
+    parser.set_defaults(handler=handlers.Status, lock=None, no_report=True, quiet=True, unsafe=True)
+    return parser
+
+
+def _set_package_status_remove_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for package status remove subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("package-status-remove", help="remove package status",
+                             description="remove the package from the status page",
+                             epilog="Please note that this subcommand does not remove the package itself, it just "
+                                    "clears the status page.",
+                             formatter_class=_formatter)
+    parser.add_argument("package", help="remove specified packages", nargs="+")
+    parser.set_defaults(handler=handlers.StatusUpdate, action=Action.Remove, lock=None, no_report=True, quiet=True,
+                        unsafe=True)
+    return parser
+
+
+def _set_package_status_update_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for package status update subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("package-status-update", aliases=["status-update"], help="update package status",
+                             description="update package status on the status page", formatter_class=_formatter)
+    parser.add_argument("package", help="set status for specified packages. "
+                                        "If no packages supplied, service status will be updated",
+                        nargs="*")
+    parser.add_argument("-s", "--status", help="new status",
+                        type=BuildStatusEnum, choices=BuildStatusEnum, default=BuildStatusEnum.Success)
+    parser.set_defaults(handler=handlers.StatusUpdate, action=Action.Update, lock=None, no_report=True, quiet=True,
+                        unsafe=True)
+    return parser
+
+
+def _set_patch_add_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for new patch subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("patch-add", help="add patch set", description="create or update source patches",
+                             epilog="In order to add a patch set for the package you will need to clone "
+                                    "the AUR package manually, add required changes (e.g. external patches, "
+                                    "edit PKGBUILD) and run command, e.g. `ahriman patch path/to/directory`. "
+                                    "By default it tracks *.patch and *.diff files, but this behavior can be changed "
+                                    "by using --track option",
+                             formatter_class=_formatter)
+    parser.add_argument("package", help="path to directory with changed files for patch addition/update")
+    parser.add_argument("-t", "--track", help="files which has to be tracked", action="append",
+                        default=["*.diff", "*.patch"])
+    parser.set_defaults(handler=handlers.Patch, action=Action.Update, architecture=[""], lock=None, no_report=True)
+    return parser
+
+
+def _set_patch_list_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for list patches subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("patch-list", help="list patch sets",
+                             description="list available patches for the package", formatter_class=_formatter)
+    parser.add_argument("package", help="package base", nargs="?")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
+    parser.set_defaults(handler=handlers.Patch, action=Action.List, architecture=[""], lock=None, no_report=True)
+    return parser
+
+
+def _set_patch_remove_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for remove patches subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("patch-remove", help="remove patch set", description="remove patches for the package",
+                             formatter_class=_formatter)
+    parser.add_argument("package", help="package base")
+    parser.set_defaults(handler=handlers.Patch, action=Action.Remove, architecture=[""], lock=None, no_report=True)
+    return parser
+
+
+def _set_repo_check_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for repository check subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("repo-check", aliases=["check"], help="check for updates",
+                             description="check for packages updates. Same as update --dry-run --no-manual",
+                             formatter_class=_formatter)
+    parser.add_argument("package", help="filter check by package base", nargs="*")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
+    parser.add_argument("--no-vcs", help="do not check VCS packages", action="store_true")
+    parser.set_defaults(handler=handlers.Update, dry_run=True, no_aur=False, no_local=False, no_manual=True)
+    return parser
+
+
+def _set_repo_clean_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for repository clean subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("repo-clean", aliases=["clean"], help="clean local caches",
+                             description="remove local caches",
+                             epilog="The subcommand clears every temporary directories (builds, caches etc). Normally "
+                                    "you should not run this command manually. Also in case if you are going to clear "
+                                    "the chroot directories you will need root privileges.",
+                             formatter_class=_formatter)
+    parser.add_argument("--cache", help="clear directory with package caches", action="store_true")
+    parser.add_argument("--chroot", help="clear build chroot", action="store_true")
+    parser.add_argument("--manual", help="clear manually added packages queue", action="store_true")
+    parser.add_argument("--packages", help="clear directory with built packages", action="store_true")
+    parser.set_defaults(handler=handlers.Clean, quiet=True, unsafe=True)
+    return parser
+
+
+def _set_repo_config_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for config subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("repo-config", aliases=["config"], help="dump configuration",
+                             description="dump configuration for the specified architecture",
+                             formatter_class=_formatter)
+    parser.set_defaults(handler=handlers.Dump, lock=None, no_report=True, quiet=True, unsafe=True)
+    return parser
+
+
+def _set_repo_rebuild_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for repository rebuild subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("repo-rebuild", aliases=["rebuild"], help="rebuild repository",
+                             description="force rebuild whole repository", formatter_class=_formatter)
+    parser.add_argument("--depends-on", help="only rebuild packages that depend on specified package", action="append")
+    parser.add_argument("--dry-run", help="just perform check for packages without rebuild process itself",
+                        action="store_true")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
+    parser.set_defaults(handler=handlers.Rebuild)
+    return parser
+
+
+def _set_repo_remove_unknown_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
     add parser for remove unknown packages subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("remove-unknown", help="remove unknown packages",
-                             description="remove packages which are missing in AUR",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("repo-remove-unknown", aliases=["remove-unknown"], help="remove unknown packages",
+                             description="remove packages which are missing in AUR and do not have local PKGBUILDs",
+                             formatter_class=_formatter)
     parser.add_argument("--dry-run", help="just perform check for packages without removal", action="store_true")
+    parser.add_argument("-i", "--info", help="show additional package information", action="store_true")
     parser.set_defaults(handler=handlers.RemoveUnknown)
     return parser
 
 
-def _set_report_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_repo_report_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
     add parser for report subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("report", help="generate report", description="generate report",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("repo-report", aliases=["report"], help="generate report",
+                             description="generate repository report according to current settings",
+                             epilog="Create and/or update repository report as configured.",
+                             formatter_class=_formatter)
     parser.add_argument("target", help="target to generate report", nargs="*")
     parser.set_defaults(handler=handlers.Report)
     return parser
 
 
-def _set_search_parser(root: SubParserAction) -> argparse.ArgumentParser:
-    """
-    add parser for search subcommand
-    :param root: subparsers for the commands
-    :return: created argument parser
-    """
-    parser = root.add_parser("search", help="search for package", description="search for package in AUR using API")
-    parser.add_argument("search", help="search terms, can be specified multiple times", nargs="+")
-    parser.set_defaults(handler=handlers.Search, architecture=[""], lock=None, no_log=True, no_report=True, unsafe=True)
-    return parser
-
-
-def _set_setup_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_repo_setup_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
     add parser for setup subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("setup", help="initial service configuration",
+    parser = root.add_parser("repo-setup", aliases=["init", "repo-init", "setup"], help="initial service configuration",
                              description="create initial service configuration, requires root",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+                             epilog="Create _minimal_ configuration for the service according to provided options.",
+                             formatter_class=_formatter)
+    parser.add_argument("--build-as-user", help="force makepkg user to the specific one")
     parser.add_argument("--build-command", help="build command prefix", default="ahriman")
     parser.add_argument("--from-configuration", help="path to default devtools pacman configuration",
                         type=Path, default=Path("/usr/share/devtools/pacman-extra.conf"))
@@ -253,115 +427,130 @@ def _set_setup_parser(root: SubParserAction) -> argparse.ArgumentParser:
     parser.add_argument("--packager", help="packager name and email", required=True)
     parser.add_argument("--repository", help="repository name", required=True)
     parser.add_argument("--sign-key", help="sign key id")
-    parser.add_argument("--sign-target", help="sign options", type=SignSettings.from_option,
-                        choices=SignSettings, action="append")
+    parser.add_argument("--sign-target", help="sign options", action="append",
+                        type=SignSettings.from_option, choices=SignSettings)
     parser.add_argument("--web-port", help="port of the web service", type=int)
-    parser.set_defaults(handler=handlers.Setup, lock=None, no_log=True, no_report=True, unsafe=True)
+    parser.set_defaults(handler=handlers.Setup, lock=None, no_report=True, quiet=True, unsafe=True)
     return parser
 
 
-def _set_sign_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_repo_sign_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
     add parser for sign subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("sign", help="sign packages", description="(re-)sign packages and repository database",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("repo-sign", aliases=["sign"], help="sign packages",
+                             description="(re-)sign packages and repository database according to current settings",
+                             epilog="Sign repository and/or packages as configured.",
+                             formatter_class=_formatter)
     parser.add_argument("package", help="sign only specified packages", nargs="*")
     parser.set_defaults(handler=handlers.Sign)
     return parser
 
 
-def _set_status_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_repo_status_update_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for status subcommand
+    add parser for repository status update subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("status", help="get package status", description="request status of the package",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument("--ahriman", help="get service status itself", action="store_true")
-    parser.add_argument("--status", help="filter packages by status", choices=BuildStatusEnum, type=BuildStatusEnum)
-    parser.add_argument("package", help="filter status by package base", nargs="*")
-    parser.set_defaults(handler=handlers.Status, lock=None, no_log=True, no_report=True, unsafe=True)
+    parser = root.add_parser("repo-status-update", help="update repository status",
+                             description="update repository status on the status page", formatter_class=_formatter)
+    parser.add_argument("-s", "--status", help="new status",
+                        type=BuildStatusEnum, choices=BuildStatusEnum, default=BuildStatusEnum.Success)
+    parser.set_defaults(handler=handlers.StatusUpdate, action=Action.Update, lock=None, no_report=True, package=[],
+                        quiet=True, unsafe=True)
     return parser
 
 
-def _set_status_update_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_repo_sync_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for status update subcommand
+    add parser for repository sync subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("status-update", help="update package status", description="request status of the package",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
-    parser.add_argument(
-        "package",
-        help="set status for specified packages. If no packages supplied, service status will be updated",
-        nargs="*")
-    parser.add_argument("--status", help="new status", choices=BuildStatusEnum,
-                        type=BuildStatusEnum, default=BuildStatusEnum.Success)
-    parser.add_argument("--remove", help="remove package status page", action="store_true")
-    parser.set_defaults(handler=handlers.StatusUpdate, lock=None, no_log=True, no_report=True, unsafe=True)
-    return parser
-
-
-def _set_sync_parser(root: SubParserAction) -> argparse.ArgumentParser:
-    """
-    add parser for sync subcommand
-    :param root: subparsers for the commands
-    :return: created argument parser
-    """
-    parser = root.add_parser("sync", help="sync repository", description="sync packages to remote server",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("repo-sync", aliases=["sync"], help="sync repository",
+                             description="sync repository files to remote server according to current settings",
+                             epilog="Synchronize the repository to remote services as configured.",
+                             formatter_class=_formatter)
     parser.add_argument("target", help="target to sync", nargs="*")
     parser.set_defaults(handler=handlers.Sync)
     return parser
 
 
-def _set_update_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_repo_update_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
-    add parser for update subcommand
+    add parser for repository update subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("update", help="update packages", description="run updates",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("repo-update", aliases=["update"], help="update packages",
+                             description="check for packages updates and run build process if requested",
+                             formatter_class=_formatter)
     parser.add_argument("package", help="filter check by package base", nargs="*")
     parser.add_argument("--dry-run", help="just perform check for updates, same as check command", action="store_true")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
     parser.add_argument("--no-aur", help="do not check for AUR updates. Implies --no-vcs", action="store_true")
+    parser.add_argument("--no-local", help="do not check local packages for updates", action="store_true")
     parser.add_argument("--no-manual", help="do not include manual updates", action="store_true")
     parser.add_argument("--no-vcs", help="do not check VCS packages", action="store_true")
     parser.set_defaults(handler=handlers.Update)
     return parser
 
 
-def _set_user_parser(root: SubParserAction) -> argparse.ArgumentParser:
+def _set_user_add_parser(root: SubParserAction) -> argparse.ArgumentParser:
     """
     add parser for create user subcommand
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser(
-        "user",
-        help="manage users for web services",
-        description="manage users for web services with password and role. In case if password was not entered it will be asked interactively",
-        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("user-add", help="create or update user",
+                             description="update user for web services with the given password and role. "
+                                         "In case if password was not entered it will be asked interactively",
+                             formatter_class=_formatter)
     parser.add_argument("username", help="username for web service")
     parser.add_argument("--as-service", help="add user as service user", action="store_true")
-    parser.add_argument(
-        "-a",
-        "--access",
-        help="user access level",
-        type=UserAccess,
-        choices=UserAccess,
-        default=UserAccess.Read)
-    parser.add_argument("--no-reload", help="do not reload authentication module", action="store_true")
-    parser.add_argument("-p", "--password", help="user password")
-    parser.add_argument("-r", "--remove", help="remove user from configuration", action="store_true")
-    parser.add_argument("--secure", help="set file permissions to user-only", action="store_true")
-    parser.set_defaults(handler=handlers.User, architecture=[""], lock=None, no_log=True, no_report=True, unsafe=True)
+    parser.add_argument("-p", "--password", help="user password. Blank password will be treated as empty password, "
+                                                 "which is in particular must be used for OAuth2 authorization type.")
+    parser.add_argument("-r", "--role", help="user access level",
+                        type=UserAccess, choices=UserAccess, default=UserAccess.Read)
+    parser.add_argument("-s", "--secure", help="set file permissions to user-only", action="store_true")
+    parser.set_defaults(handler=handlers.User, action=Action.Update, architecture=[""], lock=None, no_report=True,
+                        quiet=True, unsafe=True)
+    return parser
+
+
+def _set_user_list_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for user list subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("user-list", help="user known users and their access",
+                             description="list users from the user mapping and their roles",
+                             formatter_class=_formatter)
+    parser.add_argument("username", help="filter users by username", nargs="?")
+    parser.add_argument("-e", "--exit-code", help="return non-zero exit status if result is empty", action="store_true")
+    parser.add_argument("-r", "--role", help="filter users by role", type=UserAccess, choices=UserAccess)
+    parser.set_defaults(handler=handlers.User, action=Action.List, architecture=[""], lock=None, no_report=True,  # nosec
+                        password="", quiet=True, unsafe=True)
+    return parser
+
+
+def _set_user_remove_parser(root: SubParserAction) -> argparse.ArgumentParser:
+    """
+    add parser for user removal subcommand
+    :param root: subparsers for the commands
+    :return: created argument parser
+    """
+    parser = root.add_parser("user-remove", help="remove user",
+                             description="remove user from the user mapping and update the configuration",
+                             formatter_class=_formatter)
+    parser.add_argument("username", help="username for web service")
+    parser.add_argument("-s", "--secure", help="set file permissions to user-only", action="store_true")
+    parser.set_defaults(handler=handlers.User, action=Action.Remove, architecture=[""], lock=None, no_report=True,  # nosec
+                        password="", quiet=True, unsafe=True)
     return parser
 
 
@@ -371,8 +560,7 @@ def _set_web_parser(root: SubParserAction) -> argparse.ArgumentParser:
     :param root: subparsers for the commands
     :return: created argument parser
     """
-    parser = root.add_parser("web", help="start web server", description="start web server",
-                             formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser = root.add_parser("web", help="web server", description="start web server", formatter_class=_formatter)
     parser.set_defaults(handler=handlers.Web, lock=None, no_report=True, parser=_parser)
     return parser
 

src/ahriman/application/application.py

@@ -1,245 +0,0 @@
-#
-# Copyright (c) 2021 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 <http://www.gnu.org/licenses/>.
-#
-import logging
-import shutil
-
-from pathlib import Path
-from typing import Callable, Iterable, List, Set
-
-from ahriman.core.build_tools.task import Task
-from ahriman.core.configuration import Configuration
-from ahriman.core.repository.repository import Repository
-from ahriman.core.tree import Tree
-from ahriman.core.util import package_like
-from ahriman.models.package import Package
-from ahriman.models.package_source import PackageSource
-
-
-class Application:
-    """
-    base application class
-    :ivar architecture: repository architecture
-    :ivar configuration: configuration instance
-    :ivar logger: application logger
-    :ivar repository: repository instance
-    """
-
-    def __init__(self, architecture: str, configuration: Configuration, no_report: bool) -> None:
-        """
-        default constructor
-        :param architecture: repository architecture
-        :param configuration: configuration instance
-        :param no_report: force disable reporting
-        """
-        self.logger = logging.getLogger("root")
-        self.configuration = configuration
-        self.architecture = architecture
-        self.repository = Repository(architecture, configuration, no_report)
-
-    def _finalize(self, built_packages: Iterable[Package]) -> None:
-        """
-        generate report and sync to remote server
-        """
-        self.report([], built_packages)
-        self.sync([], built_packages)
-
-    def _known_packages(self) -> Set[str]:
-        """
-        load packages from repository and pacman repositories
-        :return: list of known packages
-        """
-        known_packages: Set[str] = set()
-        # local set
-        for base in self.repository.packages():
-            for package, properties in base.packages.items():
-                known_packages.add(package)
-                known_packages.update(properties.provides)
-        known_packages.update(self.repository.pacman.all_packages())
-        return known_packages
-
-    def get_updates(self, filter_packages: List[str], no_aur: bool, no_manual: bool, no_vcs: bool,
-                    log_fn: Callable[[str], None]) -> List[Package]:
-        """
-        get list of packages to run update process
-        :param filter_packages: do not check every package just specified in the list
-        :param no_aur: do not check for aur updates
-        :param no_manual: do not check for manual updates
-        :param no_vcs: do not check VCS packages
-        :param log_fn: logger function to log updates
-        :return: list of out-of-dated packages
-        """
-        updates = []
-
-        if not no_aur:
-            updates.extend(self.repository.updates_aur(filter_packages, no_vcs))
-        if not no_manual:
-            updates.extend(self.repository.updates_manual())
-
-        for package in updates:
-            log_fn(f"{package.base} = {package.version}")
-
-        return updates
-
-    def add(self, names: Iterable[str], source: PackageSource, without_dependencies: bool) -> None:
-        """
-        add packages for the next build
-        :param names: list of package bases to add
-        :param source: package source to add
-        :param without_dependencies: if set, dependency check will be disabled
-        """
-        known_packages = self._known_packages()
-
-        def add_directory(path: Path) -> None:
-            for full_path in filter(package_like, path.iterdir()):
-                add_archive(full_path)
-
-        def add_manual(src: str) -> Path:
-            package = Package.load(src, self.repository.pacman, self.configuration.get("alpm", "aur_url"))
-            path = self.repository.paths.manual / package.base
-            Task.fetch(path, package.git_url)
-            return path
-
-        def add_archive(src: Path) -> None:
-            dst = self.repository.paths.packages / src.name
-            shutil.move(src, dst)
-
-        def process_dependencies(path: Path) -> None:
-            if without_dependencies:
-                return
-            dependencies = Package.dependencies(path)
-            self.add(dependencies.difference(known_packages), PackageSource.AUR, without_dependencies)
-
-        def process_single(src: str) -> None:
-            resolved_source = source.resolve(src)
-            if resolved_source == PackageSource.Directory:
-                add_directory(Path(src))
-            elif resolved_source == PackageSource.Archive:
-                add_archive(Path(src))
-            else:
-                path = add_manual(src)
-                process_dependencies(path)
-
-        for name in names:
-            process_single(name)
-
-    def clean(self, no_build: bool, no_cache: bool, no_chroot: bool, no_manual: bool, no_packages: bool) -> None:
-        """
-        run all clean methods. Warning: some functions might not be available under non-root
-        :param no_build: do not clear directory with package sources
-        :param no_cache: do not clear directory with package caches
-        :param no_chroot: do not clear build chroot
-        :param no_manual: do not clear directory with manually added packages
-        :param no_packages: do not clear directory with built packages
-        """
-        if not no_build:
-            self.repository.clear_build()
-        if not no_cache:
-            self.repository.clear_cache()
-        if not no_chroot:
-            self.repository.clear_chroot()
-        if not no_manual:
-            self.repository.clear_manual()
-        if not no_packages:
-            self.repository.clear_packages()
-
-    def remove(self, names: Iterable[str]) -> None:
-        """
-        remove packages from repository
-        :param names: list of packages (either base or name) to remove
-        """
-        self.repository.process_remove(names)
-        self._finalize([])
-
-    def report(self, target: Iterable[str], built_packages: Iterable[Package]) -> None:
-        """
-        generate report
-        :param target: list of targets to run (e.g. html)
-        :param built_packages: list of packages which has just been built
-        """
-        targets = target or None
-        self.repository.process_report(targets, built_packages)
-
-    def sign(self, packages: Iterable[str]) -> None:
-        """
-        sign packages and repository
-        :param packages: only sign specified packages
-        """
-        # copy to prebuilt directory
-        for package in self.repository.packages():
-            # no one requested this package
-            if packages and package.base not in packages:
-                continue
-            for archive in package.packages.values():
-                if archive.filepath is None:
-                    self.logger.warning("filepath is empty for %s", package.base)
-                    continue  # avoid mypy warning
-                src = self.repository.paths.repository / archive.filepath
-                dst = self.repository.paths.packages / archive.filepath
-                shutil.copy(src, dst)
-        # run generic update function
-        self.update([])
-        # sign repository database if set
-        self.repository.sign.sign_repository(self.repository.repo.repo_path)
-        self._finalize([])
-
-    def sync(self, target: Iterable[str], built_packages: Iterable[Package]) -> None:
-        """
-        sync to remote server
-        :param target: list of targets to run (e.g. s3)
-        :param built_packages: list of packages which has just been built
-        """
-        targets = target or None
-        self.repository.process_sync(targets, built_packages)
-
-    def unknown(self) -> List[Package]:
-        """
-        get packages which were not found in AUR
-        :return: unknown package list
-        """
-        packages = []
-        for base in self.repository.packages():
-            try:
-                _ = Package.from_aur(base.base, base.aur_url)
-            except Exception:
-                packages.append(base)
-        return packages
-
-    def update(self, updates: Iterable[Package]) -> None:
-        """
-        run package updates
-        :param updates: list of packages to update
-        """
-        def process_update(paths: Iterable[Path]) -> None:
-            if not paths:
-                return  # don't need to process if no update supplied
-            updated = [Package.load(path, self.repository.pacman, self.repository.aur_url) for path in paths]
-            self.repository.process_update(paths)
-            self._finalize(updated)
-
-        # process built packages
-        packages = self.repository.packages_built()
-        process_update(packages)
-
-        # process manual packages
-        tree = Tree.load(updates)
-        for num, level in enumerate(tree.levels()):
-            self.logger.info("processing level #%i %s", num, [package.base for package in level])
-            packages = self.repository.process_build(level)
-            process_update(packages)

src/ahriman/application/application/__init__.py

@@ -0,0 +1,20 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from ahriman.application.application.application import Application

src/ahriman/application/application/application.py

@@ -0,0 +1,52 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from typing import Set
+
+from ahriman.application.application.packages import Packages
+from ahriman.application.application.repository import Repository
+from ahriman.models.result import Result
+
+
+class Application(Packages, Repository):
+    """
+    base application class
+    """
+
+    def _finalize(self, result: Result) -> None:
+        """
+        generate report and sync to remote server
+        :param result: build result
+        """
+        self.report([], result)
+        self.sync([], result.success)
+
+    def _known_packages(self) -> Set[str]:
+        """
+        load packages from repository and pacman repositories
+        :return: list of known packages
+        """
+        known_packages: Set[str] = set()
+        # local set
+        for base in self.repository.packages():
+            for package, properties in base.packages.items():
+                known_packages.add(package)
+                known_packages.update(properties.provides)
+        known_packages.update(self.repository.pacman.all_packages())
+        return known_packages

src/ahriman/application/application/packages.py

@@ -0,0 +1,146 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import requests
+import shutil
+
+from pathlib import Path
+from typing import Any, Iterable, Set
+
+from ahriman.application.application.properties import Properties
+from ahriman.core.build_tools.sources import Sources
+from ahriman.core.util import package_like, tmpdir
+from ahriman.models.package import Package
+from ahriman.models.package_source import PackageSource
+from ahriman.models.result import Result
+
+
+class Packages(Properties):
+    """
+    package control class
+    """
+
+    def _finalize(self, result: Result) -> None:
+        """
+        generate report and sync to remote server
+        :param result: build result
+        """
+        raise NotImplementedError
+
+    def _known_packages(self) -> Set[str]:
+        """
+        load packages from repository and pacman repositories
+        :return: list of known packages
+        """
+        raise NotImplementedError
+
+    def _add_archive(self, source: str, *_: Any) -> None:
+        """
+        add package from archive
+        :param source: path to package archive
+        """
+        local_path = Path(source)
+        dst = self.repository.paths.packages / local_path.name
+        shutil.copy(local_path, dst)
+
+    def _add_aur(self, source: str, known_packages: Set[str], without_dependencies: bool) -> None:
+        """
+        add package from AUR
+        :param source: package base name
+        :param known_packages: list of packages which are known by the service
+        :param without_dependencies: if set, dependency check will be disabled
+        """
+        package = Package.load(source, PackageSource.AUR, self.repository.pacman, self.repository.aur_url)
+        self.repository.database.build_queue_insert(package)
+
+        with tmpdir() as local_path:
+            Sources.load(local_path, package.git_url, self.database.patches_get(package.base))
+            self._process_dependencies(local_path, known_packages, without_dependencies)
+
+    def _add_directory(self, source: str, *_: Any) -> None:
+        """
+        add packages from directory
+        :param source: path to local directory
+        """
+        local_path = Path(source)
+        for full_path in filter(package_like, local_path.iterdir()):
+            self._add_archive(str(full_path))
+
+    def _add_local(self, source: str, known_packages: Set[str], without_dependencies: bool) -> None:
+        """
+        add package from local PKGBUILDs
+        :param source: path to directory with local source files
+        :param known_packages: list of packages which are known by the service
+        :param without_dependencies: if set, dependency check will be disabled
+        """
+        package = Package.load(source, PackageSource.Local, self.repository.pacman, self.repository.aur_url)
+        cache_dir = self.repository.paths.cache_for(package.base)
+        shutil.copytree(Path(source), cache_dir)  # copy package to store in caches
+        Sources.init(cache_dir)  # we need to run init command in directory where we do have permissions
+        self.repository.database.build_queue_insert(package)
+
+        self._process_dependencies(cache_dir, known_packages, without_dependencies)
+
+    def _add_remote(self, source: str, *_: Any) -> None:
+        """
+        add package from remote sources (e.g. HTTP)
+        :param remote_url: remote URL to the package archive
+        """
+        dst = self.repository.paths.packages / Path(source).name  # URL is path, is not it?
+        response = requests.get(source, stream=True)
+        response.raise_for_status()
+
+        with dst.open("wb") as local_file:
+            for chunk in response.iter_content(chunk_size=1024):
+                local_file.write(chunk)
+
+    def _process_dependencies(self, local_path: Path, known_packages: Set[str], without_dependencies: bool) -> None:
+        """
+        process package dependencies
+        :param local_path: path to local package sources (i.e. cloned AUR repository)
+        :param known_packages: list of packages which are known by the service
+        :param without_dependencies: if set, dependency check will be disabled
+        """
+        if without_dependencies:
+            return
+
+        dependencies = Package.dependencies(local_path)
+        self.add(dependencies.difference(known_packages), PackageSource.AUR, without_dependencies)
+
+    def add(self, names: Iterable[str], source: PackageSource, without_dependencies: bool) -> None:
+        """
+        add packages for the next build
+        :param names: list of package bases to add
+        :param source: package source to add
+        :param without_dependencies: if set, dependency check will be disabled
+        """
+        known_packages = self._known_packages()  # speedup dependencies processing
+
+        for name in names:
+            resolved_source = source.resolve(name)
+            fn = getattr(self, f"_add_{resolved_source.value}")
+            fn(name, known_packages, without_dependencies)
+
+    def remove(self, names: Iterable[str]) -> None:
+        """
+        remove packages from repository
+        :param names: list of packages (either base or name) to remove
+        """
+        self.repository.process_remove(names)
+        self._finalize(Result())

src/ahriman/application/application/properties.py

@@ -0,0 +1,49 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import logging
+
+from ahriman.core.configuration import Configuration
+from ahriman.core.database.sqlite import SQLite
+from ahriman.core.repository import Repository
+
+
+class Properties:
+    """
+    application base properties class
+    :ivar architecture: repository architecture
+    :ivar configuration: configuration instance
+    :ivar database: database instance
+    :ivar logger: application logger
+    :ivar repository: repository instance
+    """
+
+    def __init__(self, architecture: str, configuration: Configuration, no_report: bool, unsafe: bool) -> None:
+        """
+        default constructor
+        :param architecture: repository architecture
+        :param configuration: configuration instance
+        :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
+        """
+        self.logger = logging.getLogger("root")
+        self.configuration = configuration
+        self.architecture = architecture
+        self.database = SQLite.load(configuration)
+        self.repository = Repository(architecture, configuration, self.database, no_report, unsafe)

src/ahriman/application/application/repository.py

@@ -0,0 +1,188 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import shutil
+
+from pathlib import Path
+from typing import Callable, Iterable, List
+
+from ahriman.application.application.properties import Properties
+from ahriman.core.build_tools.sources import Sources
+from ahriman.core.formatters.update_printer import UpdatePrinter
+from ahriman.core.tree import Tree
+from ahriman.models.package import Package
+from ahriman.models.result import Result
+
+
+class Repository(Properties):
+    """
+    repository control class
+    """
+
+    def _finalize(self, result: Result) -> None:
+        """
+        generate report and sync to remote server
+        :param result: build result
+        """
+        raise NotImplementedError
+
+    def clean(self, cache: bool, chroot: bool, manual: bool, packages: bool) -> None:
+        """
+        run all clean methods. Warning: some functions might not be available under non-root
+        :param cache: clear directory with package caches
+        :param chroot: clear build chroot
+        :param manual: clear directory with manually added packages
+        :param packages: clear directory with built packages
+        """
+        if cache:
+            self.repository.clear_cache()
+        if chroot:
+            self.repository.clear_chroot()
+        if manual:
+            self.repository.clear_queue()
+        if packages:
+            self.repository.clear_packages()
+
+    def report(self, target: Iterable[str], result: Result) -> None:
+        """
+        generate report
+        :param target: list of targets to run (e.g. html)
+        :param result: build result
+        """
+        targets = target or None
+        self.repository.process_report(targets, result)
+
+    def sign(self, packages: Iterable[str]) -> None:
+        """
+        sign packages and repository
+        :param packages: only sign specified packages
+        """
+        # copy to prebuilt directory
+        for package in self.repository.packages():
+            # no one requested this package
+            if packages and package.base not in packages:
+                continue
+            for archive in package.packages.values():
+                if archive.filepath is None:
+                    self.logger.warning("filepath is empty for %s", package.base)
+                    continue  # avoid mypy warning
+                src = self.repository.paths.repository / archive.filepath
+                dst = self.repository.paths.packages / archive.filepath
+                shutil.copy(src, dst)
+        # run generic update function
+        self.update([])
+        # sign repository database if set
+        self.repository.sign.process_sign_repository(self.repository.repo.repo_path)
+        self._finalize(Result())
+
+    def sync(self, target: Iterable[str], built_packages: Iterable[Package]) -> None:
+        """
+        sync to remote server
+        :param target: list of targets to run (e.g. s3)
+        :param built_packages: list of packages which has just been built
+        """
+        targets = target or None
+        self.repository.process_sync(targets, built_packages)
+
+    def unknown(self) -> List[str]:
+        """
+        get packages which were not found in AUR
+        :return: unknown package archive list
+        """
+        def has_local(probe: Package) -> bool:
+            cache_dir = self.repository.paths.cache_for(probe.base)
+            return cache_dir.is_dir() and not Sources.has_remotes(cache_dir)
+
+        def unknown_aur(probe: Package) -> List[str]:
+            packages: List[str] = []
+            for single in probe.packages:
+                try:
+                    _ = Package.from_aur(single, probe.aur_url)
+                except Exception:
+                    packages.append(single)
+            return packages
+
+        def unknown_local(probe: Package) -> List[str]:
+            cache_dir = self.repository.paths.cache_for(probe.base)
+            local = Package.from_build(cache_dir, probe.aur_url)
+            packages = set(probe.packages.keys()).difference(local.packages.keys())
+            return list(packages)
+
+        result = []
+        for package in self.repository.packages():
+            if has_local(package):
+                result.extend(unknown_local(package))  # there is local package
+            else:
+                result.extend(unknown_aur(package))  # local package not found
+        return result
+
+    def update(self, updates: Iterable[Package]) -> Result:
+        """
+        run package updates
+        :param updates: list of packages to update
+        """
+        def process_update(paths: Iterable[Path], result: Result) -> None:
+            if not paths:
+                return  # don't need to process if no update supplied
+            update_result = self.repository.process_update(paths)
+            self._finalize(result.merge(update_result))
+
+        # process built packages
+        build_result = Result()
+        packages = self.repository.packages_built()
+        process_update(packages, build_result)
+
+        # process manual packages
+        tree = Tree.load(updates, self.database)
+        for num, level in enumerate(tree.levels()):
+            self.logger.info("processing level #%i %s", num, [package.base for package in level])
+            build_result = self.repository.process_build(level)
+            packages = self.repository.packages_built()
+            process_update(packages, build_result)
+
+        return build_result
+
+    def updates(self, filter_packages: Iterable[str], no_aur: bool, no_local: bool, no_manual: bool, no_vcs: bool,
+                log_fn: Callable[[str], None]) -> List[Package]:
+        """
+        get list of packages to run update process
+        :param filter_packages: do not check every package just specified in the list
+        :param no_aur: do not check for aur updates
+        :param no_local: do not check local packages for updates
+        :param no_manual: do not check for manual updates
+        :param no_vcs: do not check VCS packages
+        :param log_fn: logger function to log updates
+        :return: list of out-of-dated packages
+        """
+        updates = {}
+
+        if not no_aur:
+            updates.update({package.base: package for package in self.repository.updates_aur(filter_packages, no_vcs)})
+        if not no_local:
+            updates.update({package.base: package for package in self.repository.updates_local()})
+        if not no_manual:
+            updates.update({package.base: package for package in self.repository.updates_manual()})
+
+        local_versions = {package.base: package.version for package in self.repository.packages()}
+        updated_packages = [package for _, package in sorted(updates.items())]
+        for package in updated_packages:
+            UpdatePrinter(package, local_versions.get(package.base)).print(
+                verbose=True, log_fn=log_fn, separator=" -> ")
+
+        return updated_packages

src/ahriman/application/handlers/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -22,8 +22,9 @@ from ahriman.application.handlers.handler import Handler
 from ahriman.application.handlers.add import Add
 from ahriman.application.handlers.clean import Clean
 from ahriman.application.handlers.dump import Dump
-from ahriman.application.handlers.init import Init
+from ahriman.application.handlers.help import Help
 from ahriman.application.handlers.key_import import KeyImport
+from ahriman.application.handlers.patch import Patch
 from ahriman.application.handlers.rebuild import Rebuild
 from ahriman.application.handlers.remove import Remove
 from ahriman.application.handlers.remove_unknown import RemoveUnknown
@@ -34,6 +35,7 @@ from ahriman.application.handlers.sign import Sign
 from ahriman.application.handlers.status import Status
 from ahriman.application.handlers.status_update import StatusUpdate
 from ahriman.application.handlers.sync import Sync
+from ahriman.application.handlers.unsafe_commands import UnsafeCommands
 from ahriman.application.handlers.update import Update
 from ahriman.application.handlers.user import User
 from ahriman.application.handlers.web import Web

src/ahriman/application/handlers/add.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -33,18 +33,20 @@ class Add(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        application = Application(architecture, configuration, no_report)
+        application = Application(architecture, configuration, no_report, unsafe)
         application.add(args.package, args.source, args.without_dependencies)
         if not args.now:
             return
 
-        packages = application.get_updates(args.package, True, False, True, application.logger.info)
-        application.update(packages)
+        packages = application.updates(args.package, True, True, False, True, application.logger.info)
+        result = application.update(packages)
+        Add.check_if_empty(args.exit_code, result.is_empty)

src/ahriman/application/handlers/clean.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -33,13 +33,14 @@ class Clean(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        Application(architecture, configuration, no_report).clean(args.no_build, args.no_cache, args.no_chroot,
-                                                                  args.no_manual, args.no_packages)
+        Application(architecture, configuration, no_report, unsafe).clean(
+            args.cache, args.chroot, args.manual, args.packages)

src/ahriman/application/handlers/dump.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -23,6 +23,7 @@ from typing import Type
 
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
+from ahriman.core.formatters.configuration_printer import ConfigurationPrinter
 
 
 class Dump(Handler):
@@ -32,21 +33,17 @@ class Dump(Handler):
 
     ALLOW_AUTO_ARCHITECTURE_RUN = False
 
-    _print = print
-
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
         dump = configuration.dump()
         for section, values in sorted(dump.items()):
-            Dump._print(f"[{section}]")
-            for key, value in sorted(values.items()):
-                Dump._print(f"{key} = {value}")
-            Dump._print()
+            ConfigurationPrinter(section, values).print(verbose=False, separator=" = ")

src/ahriman/application/handlers/handler.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -23,11 +23,11 @@ import argparse
 import logging
 
 from multiprocessing import Pool
-from typing import Set, Type
+from typing import List, Type
 
 from ahriman.application.lock import Lock
 from ahriman.core.configuration import Configuration
-from ahriman.core.exceptions import MissingArchitecture, MultipleArchitecture
+from ahriman.core.exceptions import ExitCode, MissingArchitecture, MultipleArchitectures
 from ahriman.models.repository_paths import RepositoryPaths
 
 
@@ -42,46 +42,7 @@ class Handler:
     ALLOW_MULTI_ARCHITECTURE_RUN = True
 
     @classmethod
-    def call(cls: Type[Handler], args: argparse.Namespace, architecture: str) -> bool:
-        """
-        additional function to wrap all calls for multiprocessing library
-        :param args: command line args
-        :param architecture: repository architecture
-        :return: True on success, False otherwise
-        """
-        try:
-            configuration = Configuration.from_path(args.configuration, architecture, not args.no_log)
-            with Lock(args, architecture, configuration):
-                cls.run(args, architecture, configuration, args.no_report)
-            return True
-        except Exception:
-            logging.getLogger("root").exception("process exception")
-            return False
-
-    @classmethod
-    def execute(cls: Type[Handler], args: argparse.Namespace) -> int:
-        """
-        execute function for all aru
-        :param args: command line args
-        :return: 0 on success, 1 otherwise
-        """
-        architectures = cls.extract_architectures(args)
-
-        # actually we do not have to spawn another process if it is single-process application, do we?
-        if len(architectures) > 1:
-            if not cls.ALLOW_MULTI_ARCHITECTURE_RUN:
-                raise MultipleArchitecture(args.command)
-
-            with Pool(len(architectures)) as pool:
-                result = pool.starmap(
-                    cls.call, [(args, architecture) for architecture in architectures])
-        else:
-            result = [cls.call(args, architectures.pop())]
-
-        return 0 if all(result) else 1
-
-    @classmethod
-    def extract_architectures(cls: Type[Handler], args: argparse.Namespace) -> Set[str]:
+    def architectures_extract(cls: Type[Handler], args: argparse.Namespace) -> List[str]:
         """
         get known architectures
         :param args: command line args
@@ -92,7 +53,7 @@ class Handler:
             # for those cases architecture must be set explicitly
             raise MissingArchitecture(args.command)
         if args.architecture:  # architecture is specified explicitly
-            return set(args.architecture)
+            return sorted(set(args.architecture))
 
         config = Configuration()
         config.load(args.configuration)
@@ -102,16 +63,69 @@ class Handler:
 
         if not architectures:  # well we did not find anything
             raise MissingArchitecture(args.command)
-        return architectures
+        return sorted(architectures)
+
+    @classmethod
+    def call(cls: Type[Handler], args: argparse.Namespace, architecture: str) -> bool:
+        """
+        additional function to wrap all calls for multiprocessing library
+        :param args: command line args
+        :param architecture: repository architecture
+        :return: True on success, False otherwise
+        """
+        try:
+            configuration = Configuration.from_path(args.configuration, architecture, args.quiet)
+            with Lock(args, architecture, configuration):
+                cls.run(args, architecture, configuration, args.no_report, args.unsafe)
+            return True
+        except ExitCode:
+            return False
+        except Exception:
+            # we are basically always want to print error to stderr instead of default logger
+            logging.getLogger("stderr").exception("process exception")
+            return False
+
+    @classmethod
+    def execute(cls: Type[Handler], args: argparse.Namespace) -> int:
+        """
+        execute function for all aru
+        :param args: command line args
+        :return: 0 on success, 1 otherwise
+        """
+        architectures = cls.architectures_extract(args)
+
+        # actually we do not have to spawn another process if it is single-process application, do we?
+        if len(architectures) > 1:
+            if not cls.ALLOW_MULTI_ARCHITECTURE_RUN:
+                raise MultipleArchitectures(args.command)
+
+            with Pool(len(architectures)) as pool:
+                result = pool.starmap(
+                    cls.call, [(args, architecture) for architecture in architectures])
+        else:
+            result = [cls.call(args, architectures.pop())]
+
+        return 0 if all(result) else 1
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
         raise NotImplementedError
+
+    @staticmethod
+    def check_if_empty(enabled: bool, predicate: bool) -> None:
+        """
+        check condition and flag and raise ExitCode exception in case if it is enabled and condition match
+        :param enabled: if False no check will be performed
+        :param predicate: indicates condition on which exception should be thrown
+        """
+        if enabled and predicate:
+            raise ExitCode()

src/ahriman/application/handlers/help.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -21,26 +21,30 @@ import argparse
 
 from typing import Type
 
-from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
 
 
-class Init(Handler):
+class Help(Handler):
     """
-    repository init handler
+    help handler
     """
 
-    ALLOW_AUTO_ARCHITECTURE_RUN = False
+    ALLOW_AUTO_ARCHITECTURE_RUN = False  # it should be called only as "no-architecture"
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        Application(architecture, configuration, no_report).repository.repo.init()
+        parser: argparse.ArgumentParser = args.parser()
+        if args.command is None:
+            parser.parse_args(["--help"])
+        else:
+            parser.parse_args([args.command, "--help"])

src/ahriman/application/handlers/key_import.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -35,12 +35,14 @@ class KeyImport(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        Application(architecture, configuration, no_report).repository.sign.import_key(args.key_server, args.key)
+        Application(architecture, configuration, no_report, unsafe).repository.sign.key_import(
+            args.key_server, args.key)

src/ahriman/application/handlers/patch.py

@@ -0,0 +1,95 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import argparse
+
+from pathlib import Path
+from typing import List, Optional, Type
+
+from ahriman.application.application import Application
+from ahriman.application.handlers.handler import Handler
+from ahriman.core.build_tools.sources import Sources
+from ahriman.core.configuration import Configuration
+from ahriman.core.formatters.string_printer import StringPrinter
+from ahriman.models.action import Action
+from ahriman.models.package import Package
+from ahriman.models.package_source import PackageSource
+
+
+class Patch(Handler):
+    """
+    patch control handler
+    """
+
+    @classmethod
+    def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
+        """
+        callback for command line
+        :param args: command line args
+        :param architecture: repository architecture
+        :param configuration: configuration instance
+        :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
+        """
+        application = Application(architecture, configuration, no_report, unsafe)
+
+        if args.action == Action.List:
+            Patch.patch_set_list(application, args.package, args.exit_code)
+        elif args.action == Action.Remove:
+            Patch.patch_set_remove(application, args.package)
+        elif args.action == Action.Update:
+            Patch.patch_set_create(application, args.package, args.track)
+
+    @staticmethod
+    def patch_set_create(application: Application, sources_dir: str, track: List[str]) -> None:
+        """
+        create patch set for the package base
+        :param application: application instance
+        :param sources_dir: path to directory with the package sources
+        :param track: track files which match the glob before creating the patch
+        """
+        package = Package.load(sources_dir, PackageSource.Local, application.repository.pacman,
+                               application.repository.aur_url)
+        patch = Sources.patch_create(Path(sources_dir), *track)
+        application.database.patches_insert(package.base, patch)
+
+    @staticmethod
+    def patch_set_list(application: Application, package_base: Optional[str], exit_code: bool) -> None:
+        """
+        list patches available for the package base
+        :param application: application instance
+        :param package_base: package base
+        :param exit_code: raise ExitCode on empty search result
+        """
+        patches = application.database.patches_list(package_base)
+        Patch.check_if_empty(exit_code, not patches)
+
+        for base, patch in patches.items():
+            content = base if package_base is None else patch
+            StringPrinter(content).print(verbose=True)
+
+    @staticmethod
+    def patch_set_remove(application: Application, package_base: str) -> None:
+        """
+        remove patch set for the package base
+        :param application: application instance
+        :param package_base: package base
+        """
+        application.database.patches_remove(package_base)

src/ahriman/application/handlers/rebuild.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -24,6 +24,7 @@ from typing import Type
 from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
+from ahriman.core.formatters.update_printer import UpdatePrinter
 
 
 class Rebuild(Handler):
@@ -33,20 +34,25 @@ class Rebuild(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
         depends_on = set(args.depends_on) if args.depends_on else None
 
-        application = Application(architecture, configuration, no_report)
-        packages = [
-            package
-            for package in application.repository.packages()
-            if depends_on is None or depends_on.intersection(package.depends)
-        ]  # we have to use explicit list here for testing purpose
-        application.update(packages)
+        application = Application(architecture, configuration, no_report, unsafe)
+        updates = application.repository.packages_depends_on(depends_on)
+
+        Rebuild.check_if_empty(args.exit_code, not updates)
+        if args.dry_run:
+            for package in updates:
+                UpdatePrinter(package, package.version).print(verbose=True)
+            return
+
+        result = application.update(updates)
+        Rebuild.check_if_empty(args.exit_code, result.is_empty)

src/ahriman/application/handlers/remove.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -33,12 +33,13 @@ class Remove(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        Application(architecture, configuration, no_report).remove(args.package)
+        Application(architecture, configuration, no_report, unsafe).remove(args.package)

src/ahriman/application/handlers/remove_unknown.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -24,7 +24,7 @@ from typing import Type
 from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
-from ahriman.models.package import Package
+from ahriman.core.formatters.string_printer import StringPrinter
 
 
 class RemoveUnknown(Handler):
@@ -34,28 +34,21 @@ class RemoveUnknown(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        application = Application(architecture, configuration, no_report)
+        application = Application(architecture, configuration, no_report, unsafe)
         unknown_packages = application.unknown()
+
         if args.dry_run:
-            for package in unknown_packages:
-                RemoveUnknown.log_fn(package)
+            for package in sorted(unknown_packages):
+                StringPrinter(package).print(args.info)
             return
 
-        application.remove(package.base for package in unknown_packages)
-
-    @staticmethod
-    def log_fn(package: Package) -> None:
-        """
-        log package information
-        :param package: package object to log
-        """
-        print(f"=> {package.base} {package.version}")
-        print(f"   {package.web_url}")
+        application.remove(unknown_packages)

src/ahriman/application/handlers/report.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -24,6 +24,7 @@ from typing import Type
 from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
+from ahriman.models.result import Result
 
 
 class Report(Handler):
@@ -33,12 +34,13 @@ class Report(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        Application(architecture, configuration, no_report).report(args.target, [])
+        Application(architecture, configuration, no_report, unsafe).report(args.target, Result())

src/ahriman/application/handlers/search.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -18,45 +18,55 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
 import argparse
-import aur  # type: ignore
 
-from typing import Callable, Type
+from dataclasses import fields
+from typing import Callable, Iterable, List, Tuple, Type
 
 from ahriman.application.handlers.handler import Handler
+from ahriman.core.alpm.aur import AUR
 from ahriman.core.configuration import Configuration
+from ahriman.core.exceptions import InvalidOption
+from ahriman.core.formatters.aur_printer import AurPrinter
+from ahriman.models.aur_package import AURPackage
 
 
 class Search(Handler):
     """
     packages search handler
+    :cvar SORT_FIELDS: allowed fields to sort the package list
     """
 
     ALLOW_AUTO_ARCHITECTURE_RUN = False  # it should be called only as "no-architecture"
+    SORT_FIELDS = {field.name for field in fields(AURPackage) if field.default_factory is not list}
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        search = " ".join(args.search)
-        packages = aur.search(search)
-
-        # it actually always should return string
-        # explicit cast to string just to avoid mypy warning for untyped library
-        comparator: Callable[[aur.Package], str] = lambda item: str(item.package_base)
-        for package in sorted(packages, key=comparator):
-            Search.log_fn(package)
+        packages_list = AUR.multisearch(*args.search)
+        Search.check_if_empty(args.exit_code, not packages_list)
+        for package in Search.sort(packages_list, args.sort_by):
+            AurPrinter(package).print(args.info)
 
     @staticmethod
-    def log_fn(package: aur.Package) -> None:
+    def sort(packages: Iterable[AURPackage], sort_by: str) -> List[AURPackage]:
         """
-        log package information
-        :param package: package object as from AUR
+        sort package list by specified field
+        :param packages: packages list to sort
+        :param sort_by: AUR package field name to sort by
+        :return: sorted list for packages
         """
-        print(f"=> {package.package_base} {package.version}")
-        print(f"   {package.description}")
+        if sort_by not in Search.SORT_FIELDS:
+            raise InvalidOption(sort_by)
+        # always sort by package name at the last
+        # well technically it is not a string, but we can deal with it
+        comparator: Callable[[AURPackage], Tuple[str, str]] =\
+            lambda package: (getattr(package, sort_by), package.name)
+        return sorted(packages, key=comparator)

src/ahriman/application/handlers/setup.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -46,21 +46,27 @@ class Setup(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        application = Application(architecture, configuration, no_report)
-        Setup.create_makepkg_configuration(args.packager, application.repository.paths)
-        Setup.create_executable(args.build_command, architecture)
-        Setup.create_devtools_configuration(args.build_command, architecture, args.from_configuration,
+        Setup.configuration_create_ahriman(args, architecture, args.repository, configuration.include)
+        configuration.reload()
+
+        application = Application(architecture, configuration, no_report, unsafe)
+
+        Setup.configuration_create_makepkg(args.packager, application.repository.paths)
+        Setup.executable_create(args.build_command, architecture)
+        Setup.configuration_create_devtools(args.build_command, architecture, args.from_configuration,
                                             args.no_multilib, args.repository, application.repository.paths)
-        Setup.create_ahriman_configuration(args, architecture, args.repository, configuration.include)
-        Setup.create_sudo_configuration(args.build_command, architecture)
+        Setup.configuration_create_sudo(args.build_command, architecture)
+
+        application.repository.repo.init()
 
     @staticmethod
     def build_command(prefix: str, architecture: str) -> Path:
@@ -73,7 +79,7 @@ class Setup(Handler):
         return Setup.BIN_DIR_PATH / f"{prefix}-{architecture}-build"
 
     @staticmethod
-    def create_ahriman_configuration(args: argparse.Namespace, architecture: str, repository: str,
+    def configuration_create_ahriman(args: argparse.Namespace, architecture: str, repository: str,
                                      include_path: Path) -> None:
         """
         create service specific configuration
@@ -87,6 +93,8 @@ class Setup(Handler):
         section = Configuration.section_name("build", architecture)
         configuration.set_option(section, "build_command", str(Setup.build_command(args.build_command, architecture)))
         configuration.set_option("repository", "name", repository)
+        if args.build_as_user is not None:
+            configuration.set_option(section, "makechrootpkg_flags", f"-U {args.build_as_user}")
 
         if args.sign_key is not None:
             section = Configuration.section_name("sign", architecture)
@@ -102,7 +110,7 @@ class Setup(Handler):
             configuration.write(ahriman_configuration)
 
     @staticmethod
-    def create_devtools_configuration(prefix: str, architecture: str, source: Path,
+    def configuration_create_devtools(prefix: str, architecture: str, source: Path,
                                       no_multilib: bool, repository: str, paths: RepositoryPaths) -> None:
         """
         create configuration for devtools based on `source` configuration
@@ -138,16 +146,16 @@ class Setup(Handler):
             configuration.write(devtools_configuration)
 
     @staticmethod
-    def create_makepkg_configuration(packager: str, paths: RepositoryPaths) -> None:
+    def configuration_create_makepkg(packager: str, paths: RepositoryPaths) -> None:
         """
         create configuration for makepkg
         :param packager: packager identifier (e.g. name, email)
         :param paths: repository paths instance
         """
-        (paths.root / ".makepkg.conf").write_text(f"PACKAGER='{packager}'\n")
+        (paths.root / ".makepkg.conf").write_text(f"PACKAGER='{packager}'\n", encoding="utf8")
 
     @staticmethod
-    def create_sudo_configuration(prefix: str, architecture: str) -> None:
+    def configuration_create_sudo(prefix: str, architecture: str) -> None:
         """
         create configuration to run build command with sudo without password
         :param prefix: command prefix in {prefix}-{architecture}-build
@@ -158,7 +166,7 @@ class Setup(Handler):
         Setup.SUDOERS_PATH.chmod(0o400)  # security!
 
     @staticmethod
-    def create_executable(prefix: str, architecture: str) -> None:
+    def executable_create(prefix: str, architecture: str) -> None:
         """
         create executable for the service
         :param prefix: command prefix in {prefix}-{architecture}-build

src/ahriman/application/handlers/sign.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -33,12 +33,13 @@ class Sign(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        Application(architecture, configuration, no_report).sign(args.package)
+        Application(architecture, configuration, no_report, unsafe).sign(args.package)

src/ahriman/application/handlers/status.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -24,6 +24,8 @@ from typing import Callable, Iterable, Tuple, Type
 from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
+from ahriman.core.formatters.package_printer import PackagePrinter
+from ahriman.core.formatters.status_printer import StatusPrinter
 from ahriman.models.build_status import BuildStatus
 from ahriman.models.package import Package
 
@@ -37,20 +39,20 @@ class Status(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
         # we are using reporter here
-        client = Application(architecture, configuration, no_report=False).repository.reporter
+        client = Application(architecture, configuration, no_report=False, unsafe=unsafe).repository.reporter
         if args.ahriman:
             ahriman = client.get_self()
-            print(ahriman.pretty_print())
-            print()
+            StatusPrinter(ahriman).print(args.info)
         if args.package:
             packages: Iterable[Tuple[Package, BuildStatus]] = sum(
                 [client.get(base) for base in args.package],
@@ -58,10 +60,10 @@ class Status(Handler):
         else:
             packages = client.get(None)
 
+        Status.check_if_empty(args.exit_code, not packages)
+
         comparator: Callable[[Tuple[Package, BuildStatus]], str] = lambda item: item[0].base
         filter_fn: Callable[[Tuple[Package, BuildStatus]], bool] =\
             lambda item: args.status is None or item[1].status == args.status
         for package, package_status in sorted(filter(filter_fn, packages), key=comparator):
-            print(package.pretty_print())
-            print(f"\t{package.version}")
-            print(f"\t{package_status.pretty_print()}")
+            PackagePrinter(package, package_status).print(args.info)

src/ahriman/application/handlers/status_update.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -19,12 +19,12 @@
 #
 import argparse
 
-from typing import Callable, Type
+from typing import Type
 
 from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
-from ahriman.core.exceptions import InvalidCommand
+from ahriman.models.action import Action
 
 
 class StatusUpdate(Handler):
@@ -36,23 +36,25 @@ class StatusUpdate(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
         # we are using reporter here
-        client = Application(architecture, configuration, no_report=False).repository.reporter
-        callback: Callable[[str], None] = lambda p: client.remove(p) if args.remove else client.update(p, args.status)
-        if args.package:
+        client = Application(architecture, configuration, no_report=False, unsafe=unsafe).repository.reporter
+
+        if args.action == Action.Update and args.package:
             # update packages statuses
             for package in args.package:
-                callback(package)
-        elif args.remove:
-            raise InvalidCommand("Remove option is supplied, but no packages set")
-        else:
+                client.update(package, args.status)
+        elif args.action == Action.Update:
             # update service status
             client.update_self(args.status)
+        elif args.action == Action.Remove:
+            for package in args.package:
+                client.remove(package)

src/ahriman/application/handlers/sync.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -33,12 +33,13 @@ class Sync(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        Application(architecture, configuration, no_report).sync(args.target, [])
+        Application(architecture, configuration, no_report, unsafe).sync(args.target, [])

src/ahriman/application/handlers/unsafe_commands.py

@@ -0,0 +1,78 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import argparse
+import shlex
+
+from typing import List, Type
+
+from ahriman.application.handlers.handler import Handler
+from ahriman.core.configuration import Configuration
+from ahriman.core.exceptions import ExitCode
+from ahriman.core.formatters.string_printer import StringPrinter
+
+
+class UnsafeCommands(Handler):
+    """
+    unsafe command help parser
+    """
+
+    ALLOW_AUTO_ARCHITECTURE_RUN = False  # it should be called only as "no-architecture"
+
+    @classmethod
+    def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
+        """
+        callback for command line
+        :param args: command line args
+        :param architecture: repository architecture
+        :param configuration: configuration instance
+        :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
+        """
+        parser = args.parser()
+        unsafe_commands = UnsafeCommands.get_unsafe_commands(parser)
+        if args.command is None:
+            for command in unsafe_commands:
+                StringPrinter(command).print(verbose=True)
+        else:
+            UnsafeCommands.check_unsafe(args.command, unsafe_commands, parser)
+
+    @staticmethod
+    def check_unsafe(command: str, unsafe_commands: List[str], parser: argparse.ArgumentParser) -> None:
+        """
+        check if command is unsafe
+        :param command: command to check
+        :param unsafe_commands: list of unsafe commands
+        :param parser: generated argument parser
+        """
+        args = parser.parse_args(shlex.split(command))
+        if args.command in unsafe_commands:
+            raise ExitCode()
+
+    @staticmethod
+    def get_unsafe_commands(parser: argparse.ArgumentParser) -> List[str]:
+        """
+        extract unsafe commands from argument parser
+        :param parser: generated argument parser
+        :return: list of commands with default unsafe flag
+        """
+        # pylint: disable=protected-access
+        subparser = next(action for action in parser._actions if isinstance(action, argparse._SubParsersAction))
+        return [action_name for action_name, action in subparser.choices.items() if action.get_default("unsafe")]

src/ahriman/application/handlers/update.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -33,21 +33,24 @@ class Update(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        application = Application(architecture, configuration, no_report)
-        packages = application.get_updates(args.package, args.no_aur, args.no_manual, args.no_vcs,
-                                           Update.log_fn(application, args.dry_run))
+        application = Application(architecture, configuration, no_report, unsafe)
+        packages = application.updates(args.package, args.no_aur, args.no_local, args.no_manual, args.no_vcs,
+                                       Update.log_fn(application, args.dry_run))
+        Update.check_if_empty(args.exit_code, not packages)
         if args.dry_run:
             return
 
-        application.update(packages)
+        result = application.update(packages)
+        Update.check_if_empty(args.exit_code, result.is_empty)
 
     @staticmethod
     def log_fn(application: Application, dry_run: bool) -> Callable[[str], None]:

src/ahriman/application/handlers/user.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -23,11 +23,12 @@ import getpass
 from pathlib import Path
 from typing import Type
 
-from ahriman.application.application import Application
 from ahriman.application.handlers.handler import Handler
 from ahriman.core.configuration import Configuration
+from ahriman.core.database.sqlite import SQLite
+from ahriman.core.formatters.user_printer import UserPrinter
+from ahriman.models.action import Action
 from ahriman.models.user import User as MUser
-from ahriman.models.user_access import UserAccess
 
 
 class User(Handler):
@@ -39,71 +40,52 @@ class User(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
-        salt = User.get_salt(configuration)
-        user = User.create_user(args)
-        auth_configuration = User.get_auth_configuration(configuration.include)
+        database = SQLite.load(configuration)
 
-        User.clear_user(auth_configuration, user)
-        if not args.remove:
-            User.create_configuration(auth_configuration, user, salt, args.as_service)
-        User.write_configuration(auth_configuration, args.secure)
+        if args.action == Action.Update:
+            salt = User.get_salt(configuration)
+            user = User.user_create(args)
 
-        if not args.no_reload:
-            client = Application(architecture, configuration, no_report=False).repository.reporter
-            client.reload_auth()
+            auth_configuration = User.configuration_get(configuration.include)
+
+            User.configuration_create(auth_configuration, user, salt, args.as_service, args.secure)
+            database.user_update(user.hash_password(salt))
+        elif args.action == Action.List:
+            users = database.user_list(args.username, args.role)
+            User.check_if_empty(args.exit_code, not users)
+            for user in users:
+                UserPrinter(user).print(verbose=True)
+        elif args.action == Action.Remove:
+            database.user_remove(args.username)
 
     @staticmethod
-    def clear_user(configuration: Configuration, user: MUser) -> None:
+    def configuration_create(configuration: Configuration, user: MUser, salt: str,
+                             as_service_user: bool, secure: bool) -> None:
         """
-        remove user user from configuration file in case if it exists
-        :param configuration: configuration instance
-        :param user: user descriptor
-        """
-        for role in UserAccess:
-            section = Configuration.section_name("auth", role.value)
-            if not configuration.has_option(section, user.username):
-                continue
-            configuration.remove_option(section, user.username)
-
-    @staticmethod
-    def create_configuration(configuration: Configuration, user: MUser, salt: str, as_service_user: bool) -> None:
-        """
-        put new user to configuration
+        enable configuration if it has been disabled
         :param configuration: configuration instance
         :param user: user descriptor
         :param salt: password hash salt
         :param as_service_user: add user as service user, also set password and user to configuration
+        :param secure: if true then set file permissions to 0o600
         """
-        section = Configuration.section_name("auth", user.access.value)
         configuration.set_option("auth", "salt", salt)
-        configuration.set_option(section, user.username, user.hash_password(salt))
-
         if as_service_user:
             configuration.set_option("web", "username", user.username)
             configuration.set_option("web", "password", user.password)
+        User.configuration_write(configuration, secure)
 
     @staticmethod
-    def create_user(args: argparse.Namespace) -> MUser:
-        """
-        create user descriptor from arguments
-        :param args: command line args
-        :return: built user descriptor
-        """
-        user = MUser(args.username, args.password, args.access)
-        if user.password is None:
-            user.password = getpass.getpass()
-        return user
-
-    @staticmethod
-    def get_auth_configuration(include_path: Path) -> Configuration:
+    def configuration_get(include_path: Path) -> Configuration:
         """
         create configuration instance
         :param include_path: path to directory with configuration includes
@@ -113,8 +95,23 @@ class User(Handler):
         configuration = Configuration()
         configuration.load(target)
 
+        configuration.architecture = ""  # not user anyway
+
         return configuration
 
+    @staticmethod
+    def configuration_write(configuration: Configuration, secure: bool) -> None:
+        """
+        write configuration file
+        :param configuration: configuration instance
+        :param secure: if true then set file permissions to 0o600
+        """
+        path, _ = configuration.check_loaded()
+        with path.open("w") as ahriman_configuration:
+            configuration.write(ahriman_configuration)
+        if secure:
+            path.chmod(0o600)
+
     @staticmethod
     def get_salt(configuration: Configuration, salt_length: int = 20) -> str:
         """
@@ -123,21 +120,18 @@ class User(Handler):
         :param salt_length: salt length
         :return: current salt
         """
-        salt = configuration.get("auth", "salt", fallback=None)
-        if salt:
+        if salt := configuration.get("auth", "salt", fallback=None):
             return salt
         return MUser.generate_password(salt_length)
 
     @staticmethod
-    def write_configuration(configuration: Configuration, secure: bool) -> None:
+    def user_create(args: argparse.Namespace) -> MUser:
         """
-        write configuration file
-        :param configuration: configuration instance
-        :param secure: if true then set file permissions to 0o600
+        create user descriptor from arguments
+        :param args: command line args
+        :return: built user descriptor
         """
-        if configuration.path is None:
-            return  # should never happen actually
-        with configuration.path.open("w") as ahriman_configuration:
-            configuration.write(ahriman_configuration)
-        if secure:
-            configuration.path.chmod(0o600)
+        user = MUser(args.username, args.password, args.role)
+        if user.password is None:
+            user.password = getpass.getpass()
+        return user

src/ahriman/application/handlers/web.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -36,13 +36,14 @@ class Web(Handler):
 
     @classmethod
     def run(cls: Type[Handler], args: argparse.Namespace, architecture: str,
-            configuration: Configuration, no_report: bool) -> None:
+            configuration: Configuration, no_report: bool, unsafe: bool) -> None:
         """
         callback for command line
         :param args: command line args
         :param architecture: repository architecture
         :param configuration: configuration instance
         :param no_report: force disable reporting
+        :param unsafe: if set no user check will be performed before path creation
         """
         # we are using local import for optional dependencies
         from ahriman.web.web import run_server, setup_service

src/ahriman/application/lock.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -21,7 +21,6 @@ from __future__ import annotations
 
 import argparse
 import logging
-import os
 
 from pathlib import Path
 from types import TracebackType
@@ -29,8 +28,9 @@ from typing import Literal, Optional, Type
 
 from ahriman import version
 from ahriman.core.configuration import Configuration
-from ahriman.core.exceptions import DuplicateRun, UnsafeRun
+from ahriman.core.exceptions import DuplicateRun
 from ahriman.core.status.client import Client
+from ahriman.core.util import check_user
 from ahriman.models.build_status import BuildStatusEnum
 
 
@@ -40,7 +40,7 @@ class Lock:
     :ivar force: remove lock file on start if any
     :ivar path: path to lock file if any
     :ivar reporter: build status reporter instance
-    :ivar root: repository root (i.e. ahriman home)
+    :ivar paths: repository paths instance
     :ivar unsafe: skip user check
     """
 
@@ -55,7 +55,7 @@ class Lock:
         self.force = args.force
         self.unsafe = args.unsafe
 
-        self.root = Path(configuration.get("repository", "root"))
+        self.paths = configuration.repository_paths
         self.reporter = Client() if args.no_report else Client.load(configuration)
 
     def __enter__(self) -> Lock:
@@ -103,12 +103,7 @@ class Lock:
         """
         check if current user is actually owner of ahriman root
         """
-        if self.unsafe:
-            return
-        current_uid = os.getuid()
-        root_uid = self.root.stat().st_uid
-        if current_uid != root_uid:
-            raise UnsafeRun(current_uid, root_uid)
+        check_user(self.paths, self.unsafe)
 
     def clear(self) -> None:
         """

src/ahriman/core/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/core/alpm/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/core/alpm/aur.py

@@ -0,0 +1,154 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import annotations
+
+import logging
+import requests
+
+from typing import Any, Dict, List, Optional, Type
+
+from ahriman.core.exceptions import InvalidPackageInfo
+from ahriman.core.util import exception_response_text
+from ahriman.models.aur_package import AURPackage
+
+
+class AUR:
+    """
+    AUR RPC wrapper
+    :cvar DEFAULT_RPC_URL: default AUR RPC url
+    :cvar DEFAULT_RPC_VERSION: default AUR RPC version
+    :ivar logger: class logger
+    :ivar rpc_url: AUR RPC url
+    :ivar rpc_version: AUR RPC version
+    """
+
+    DEFAULT_RPC_URL = "https://aur.archlinux.org/rpc"
+    DEFAULT_RPC_VERSION = "5"
+
+    def __init__(self, rpc_url: Optional[str] = None, rpc_version: Optional[str] = None) -> None:
+        """
+        default constructor
+        :param rpc_url: AUR RPC url
+        :param rpc_version: AUR RPC version
+        """
+        self.rpc_url = rpc_url or self.DEFAULT_RPC_URL
+        self.rpc_version = rpc_version or self.DEFAULT_RPC_VERSION
+        self.logger = logging.getLogger("build_details")
+
+    @classmethod
+    def info(cls: Type[AUR], package_name: str) -> AURPackage:
+        """
+        get package info by its name
+        :param package_name: package name to search
+        :return: package which match the package name
+        """
+        return cls().package_info(package_name)
+
+    @classmethod
+    def multisearch(cls: Type[AUR], *keywords: str) -> List[AURPackage]:
+        """
+        search in AUR by using API with multiple words. This method is required in order to handle
+        https://bugs.archlinux.org/task/49133. In addition short words will be dropped
+        :param keywords: search terms, e.g. "ahriman", "is", "cool"
+        :return: list of packages each of them matches all search terms
+        """
+        instance = cls()
+        packages: Dict[str, AURPackage] = {}
+        for term in filter(lambda word: len(word) > 3, keywords):
+            portion = instance.search(term)
+            packages = {
+                package.package_base: package
+                for package in portion
+                if package.package_base in packages or not packages
+            }
+        return list(packages.values())
+
+    @classmethod
+    def search(cls: Type[AUR], *keywords: str) -> List[AURPackage]:
+        """
+        search package in AUR web
+        :param keywords: keywords to search
+        :return: list of packages which match the criteria
+        """
+        return cls().package_search(*keywords)
+
+    @staticmethod
+    def parse_response(response: Dict[str, Any]) -> List[AURPackage]:
+        """
+        parse RPC response to package list
+        :param response: RPC response json
+        :return: list of parsed packages
+        """
+        response_type = response["type"]
+        if response_type == "error":
+            error_details = response.get("error", "Unknown API error")
+            raise InvalidPackageInfo(error_details)
+        return [AURPackage.from_json(package) for package in response["results"]]
+
+    def make_request(self, request_type: str, *args: str, **kwargs: str) -> List[AURPackage]:
+        """
+        perform request to AUR RPC
+        :param request_type: AUR request type, e.g. search, info
+        :param args: list of arguments to be passed as args query parameter
+        :param kwargs: list of additional named parameters like by
+        :return: response parsed to package list
+        """
+        query: Dict[str, Any] = {
+            "type": request_type,
+            "v": self.rpc_version
+        }
+
+        arg_query = "arg[]" if len(args) > 1 else "arg"
+        query[arg_query] = list(args)
+
+        for key, value in kwargs.items():
+            query[key] = value
+
+        try:
+            response = requests.get(self.rpc_url, params=query)
+            response.raise_for_status()
+            return self.parse_response(response.json())
+        except requests.HTTPError as e:
+            self.logger.exception(
+                "could not perform request by using type %s: %s",
+                request_type,
+                exception_response_text(e))
+            raise
+        except Exception:
+            self.logger.exception("could not perform request by using type %s", request_type)
+            raise
+
+    def package_info(self, package_name: str) -> AURPackage:
+        """
+        get package info by its name
+        :param package_name: package name to search
+        :return: package which match the package name
+        """
+        packages = self.make_request("info", package_name)
+        return next(package for package in packages if package.name == package_name)
+
+    def package_search(self, *keywords: str, by: str = "name-desc") -> List[AURPackage]:
+        """
+        search package in AUR web
+        :param keywords: keywords to search
+        :param by: search by the field
+        :return: list of packages which match the criteria
+        """
+        return self.make_request("search", *keywords, by=by)

src/ahriman/core/alpm/pacman.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/core/alpm/repo.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -34,6 +34,7 @@ class Repo:
     :ivar name: repository name
     :ivar paths: repository paths instance
     :ivar sign_args: additional args which have to be used to sign repository archive
+    :ivar uid: uid of the repository owner user
     """
 
     _check_output = check_output
@@ -48,6 +49,7 @@ class Repo:
         self.logger = logging.getLogger("build_details")
         self.name = name
         self.paths = paths
+        self.uid, _ = paths.root_owner
         self.sign_args = sign_args
 
     @property
@@ -66,7 +68,8 @@ class Repo:
             "repo-add", *self.sign_args, "-R", str(self.repo_path), str(path),
             exception=BuildFailed(path.name),
             cwd=self.paths.repository,
-            logger=self.logger)
+            logger=self.logger,
+            user=self.uid)
 
     def init(self) -> None:
         """
@@ -76,7 +79,8 @@ class Repo:
             "repo-add", *self.sign_args, str(self.repo_path),
             exception=None,
             cwd=self.paths.repository,
-            logger=self.logger)
+            logger=self.logger,
+            user=self.uid)
 
     def remove(self, package: str, filename: Path) -> None:
         """
@@ -93,4 +97,5 @@ class Repo:
             "repo-remove", *self.sign_args, str(self.repo_path), package,
             exception=BuildFailed(package),
             cwd=self.paths.repository,
-            logger=self.logger)
+            logger=self.logger,
+            user=self.uid)

src/ahriman/core/auth/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/core/auth/auth.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -21,12 +21,11 @@ from __future__ import annotations
 
 import logging
 
-from typing import Dict, Optional, Type
+from typing import Optional, Type
 
 from ahriman.core.configuration import Configuration
-from ahriman.core.exceptions import DuplicateUser
+from ahriman.core.database.sqlite import SQLite
 from ahriman.models.auth_settings import AuthSettings
-from ahriman.models.user import User
 from ahriman.models.user_access import UserAccess
 
 
@@ -63,40 +62,22 @@ class Auth:
         return """<button type="button" class="btn btn-link" data-bs-toggle="modal" data-bs-target="#loginForm" style="text-decoration: none">login</button>"""
 
     @classmethod
-    def load(cls: Type[Auth], configuration: Configuration) -> Auth:
+    def load(cls: Type[Auth], configuration: Configuration, database: SQLite) -> Auth:
         """
         load authorization module from settings
         :param configuration: configuration instance
+        :param database: database instance
         :return: authorization module according to current settings
         """
         provider = AuthSettings.from_option(configuration.get("auth", "target", fallback="disabled"))
         if provider == AuthSettings.Configuration:
             from ahriman.core.auth.mapping import Mapping
-            return Mapping(configuration)
+            return Mapping(configuration, database)
         if provider == AuthSettings.OAuth:
             from ahriman.core.auth.oauth import OAuth
-            return OAuth(configuration)
+            return OAuth(configuration, database)
         return cls(configuration)
 
-    @staticmethod
-    def get_users(configuration: Configuration) -> Dict[str, User]:
-        """
-        load users from settings
-        :param configuration: configuration instance
-        :return: map of username to its descriptor
-        """
-        users: Dict[str, User] = {}
-        for role in UserAccess:
-            section = configuration.section_name("auth", role.value)
-            if not configuration.has_section(section):
-                continue
-            for user, password in configuration[section].items():
-                normalized_user = user.lower()
-                if normalized_user in users:
-                    raise DuplicateUser(normalized_user)
-                users[normalized_user] = User(normalized_user, password, role)
-        return users
-
     async def check_credentials(self, username: Optional[str], password: Optional[str]) -> bool:  # pylint: disable=no-self-use
         """
         validate user password

src/ahriman/core/auth/helpers.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/core/auth/mapping.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -20,7 +20,9 @@
 from typing import Optional
 
 from ahriman.core.auth.auth import Auth
+
 from ahriman.core.configuration import Configuration
+from ahriman.core.database.sqlite import SQLite
 from ahriman.models.auth_settings import AuthSettings
 from ahriman.models.user import User
 from ahriman.models.user_access import UserAccess
@@ -30,18 +32,20 @@ class Mapping(Auth):
     """
     user authorization based on mapping from configuration file
     :ivar salt: random generated string to salt passwords
-    :ivar _users: map of username to its descriptor
+    :ivar database: database instance
     """
 
-    def __init__(self, configuration: Configuration, provider: AuthSettings = AuthSettings.Configuration) -> None:
+    def __init__(self, configuration: Configuration, database: SQLite,
+                 provider: AuthSettings = AuthSettings.Configuration) -> None:
         """
         default constructor
         :param configuration: configuration instance
+        :param database: database instance
         :param provider: authorization type definition
         """
         Auth.__init__(self, configuration, provider)
+        self.database = database
         self.salt = configuration.get("auth", "salt")
-        self._users = self.get_users(configuration)
 
     async def check_credentials(self, username: Optional[str], password: Optional[str]) -> bool:
         """
@@ -61,8 +65,7 @@ class Mapping(Auth):
         :param username: username
         :return: user descriptor if username is known and None otherwise
         """
-        normalized_user = username.lower()
-        return self._users.get(normalized_user)
+        return self.database.user_get(username)
 
     async def known_username(self, username: Optional[str]) -> bool:
         """

src/ahriman/core/auth/oauth.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -23,6 +23,7 @@ from typing import Optional, Type
 
 from ahriman.core.auth.mapping import Mapping
 from ahriman.core.configuration import Configuration
+from ahriman.core.database.sqlite import SQLite
 from ahriman.core.exceptions import InvalidOption
 from ahriman.models.auth_settings import AuthSettings
 
@@ -38,13 +39,15 @@ class OAuth(Mapping):
     :ivar scopes: list of scopes required by the application
     """
 
-    def __init__(self, configuration: Configuration, provider: AuthSettings = AuthSettings.OAuth) -> None:
+    def __init__(self, configuration: Configuration, database: SQLite,
+                 provider: AuthSettings = AuthSettings.OAuth) -> None:
         """
         default constructor
         :param configuration: configuration instance
+        :param database: database instance
         :param provider: authorization type definition
         """
-        Mapping.__init__(self, configuration, provider)
+        Mapping.__init__(self, configuration, database, provider)
         self.client_id = configuration.get("auth", "client_id")
         self.client_secret = configuration.get("auth", "client_secret")
         # in order to use OAuth feature the service must be publicity available
@@ -104,7 +107,6 @@ class OAuth(Mapping):
             access_token, _ = await client.get_access_token(code, redirect_uri=self.redirect_uri)
             client.access_token = access_token
 
-            print(f"HEEELOOOO {client}")
             user, _ = await client.user_info()
             username: str = user.email  # type: ignore
             return username

src/ahriman/core/build_tools/__init__.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).

src/ahriman/core/build_tools/sources.py

@@ -0,0 +1,151 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import logging
+
+from pathlib import Path
+from typing import List, Optional
+
+from ahriman.core.util import check_output
+
+
+class Sources:
+    """
+    helper to download package sources (PKGBUILD etc)
+    :cvar logger: class logger
+    """
+
+    logger = logging.getLogger("build_details")
+
+    _branch = "master"  # in case if BLM would like to change it
+    _check_output = check_output
+
+    @staticmethod
+    def add(sources_dir: Path, *pattern: str) -> None:
+        """
+        track found files via git
+        :param sources_dir: local path to git repository
+        :param pattern: glob patterns
+        """
+        # glob directory to find files which match the specified patterns
+        found_files: List[Path] = []
+        for glob in pattern:
+            found_files.extend(sources_dir.glob(glob))
+        if not found_files:
+            return  # no additional files found
+        Sources.logger.info("found matching files %s", found_files)
+        # add them to index
+        Sources._check_output("git", "add", "--intent-to-add",
+                              *[str(fn.relative_to(sources_dir)) for fn in found_files],
+                              exception=None, cwd=sources_dir, logger=Sources.logger)
+
+    @staticmethod
+    def diff(sources_dir: Path) -> str:
+        """
+        generate diff from the current version and write it to the output file
+        :param sources_dir: local path to git repository
+        :return: patch as plain string
+        """
+        return Sources._check_output("git", "diff", exception=None, cwd=sources_dir, logger=Sources.logger)
+
+    @staticmethod
+    def fetch(sources_dir: Path, remote: Optional[str]) -> None:
+        """
+        either clone repository or update it to origin/`branch`
+        :param sources_dir: local path to fetch
+        :param remote: remote target (from where to fetch)
+        """
+        # local directory exists and there is .git directory
+        is_initialized_git = (sources_dir / ".git").is_dir()
+        if is_initialized_git and not Sources.has_remotes(sources_dir):
+            # there is git repository, but no remote configured so far
+            Sources.logger.info("skip update at %s because there are no branches configured", sources_dir)
+            return
+
+        if is_initialized_git:
+            Sources.logger.info("update HEAD to remote at %s", sources_dir)
+            Sources._check_output("git", "fetch", "origin", Sources._branch,
+                                  exception=None, cwd=sources_dir, logger=Sources.logger)
+        elif remote is None:
+            Sources.logger.warning("%s is not initialized, but no remote provided", sources_dir)
+        else:
+            Sources.logger.info("clone remote %s to %s", remote, sources_dir)
+            Sources._check_output("git", "clone", remote, str(sources_dir), exception=None, logger=Sources.logger)
+        # and now force reset to our branch
+        Sources._check_output("git", "checkout", "--force", Sources._branch,
+                              exception=None, cwd=sources_dir, logger=Sources.logger)
+        Sources._check_output("git", "reset", "--hard", f"origin/{Sources._branch}",
+                              exception=None, cwd=sources_dir, logger=Sources.logger)
+
+    @staticmethod
+    def has_remotes(sources_dir: Path) -> bool:
+        """
+        check if there are remotes for the repository
+        :param sources_dir: local path to git repository
+        :return: True in case if there is any remote and false otherwise
+        """
+        remotes = Sources._check_output("git", "remote", exception=None, cwd=sources_dir, logger=Sources.logger)
+        return bool(remotes)
+
+    @staticmethod
+    def init(sources_dir: Path) -> None:
+        """
+        create empty git repository at the specified path
+        :param sources_dir: local path to sources
+        """
+        Sources._check_output("git", "init", "--initial-branch", Sources._branch,
+                              exception=None, cwd=sources_dir, logger=Sources.logger)
+
+    @staticmethod
+    def load(sources_dir: Path, remote: str, patch: Optional[str]) -> None:
+        """
+        fetch sources from remote and apply patches
+        :param sources_dir: local path to fetch
+        :param remote: remote target (from where to fetch)
+        :param patch: optional patch to be applied
+        """
+        Sources.fetch(sources_dir, remote)
+        if patch is None:
+            Sources.logger.info("no patches found")
+            return
+        Sources.patch_apply(sources_dir, patch)
+
+    @staticmethod
+    def patch_apply(sources_dir: Path, patch: str) -> None:
+        """
+        apply patches if any
+        :param sources_dir: local path to directory with git sources
+        :param patch: patch to be applied
+        """
+        # create patch
+        Sources.logger.info("apply patch from database")
+        Sources._check_output("git", "apply", "--ignore-space-change", "--ignore-whitespace",
+                              exception=None, cwd=sources_dir, input_data=patch, logger=Sources.logger)
+
+    @staticmethod
+    def patch_create(sources_dir: Path, *pattern: str) -> str:
+        """
+        create patch set for the specified local path
+        :param sources_dir: local path to git repository
+        :param pattern: glob patterns
+        :return: patch as plain text
+        """
+        Sources.add(sources_dir, *pattern)
+        diff = Sources.diff(sources_dir)
+        return f"{diff}\n"  # otherwise, patch will be broken

src/ahriman/core/build_tools/task.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -21,9 +21,11 @@ import logging
 import shutil
 
 from pathlib import Path
-from typing import List, Optional
+from typing import List
 
+from ahriman.core.build_tools.sources import Sources
 from ahriman.core.configuration import Configuration
+from ahriman.core.database.sqlite import SQLite
 from ahriman.core.exceptions import BuildFailed
 from ahriman.core.util import check_output
 from ahriman.models.package import Package
@@ -37,6 +39,7 @@ class Task:
     :ivar logger: class logger
     :ivar package: package definitions
     :ivar paths: repository paths instance
+    :ivar uid: uid of the repository owner user
     """
 
     _check_output = check_output
@@ -48,51 +51,21 @@ class Task:
         :param configuration: configuration instance
         :param paths: repository paths instance
         """
-        self.logger = logging.getLogger("builder")
+        self.logger = logging.getLogger("root")
         self.build_logger = logging.getLogger("build_details")
         self.package = package
         self.paths = paths
+        self.uid, _ = paths.root_owner
 
         self.archbuild_flags = configuration.getlist("build", "archbuild_flags", fallback=[])
         self.build_command = configuration.get("build", "build_command")
         self.makepkg_flags = configuration.getlist("build", "makepkg_flags", fallback=[])
         self.makechrootpkg_flags = configuration.getlist("build", "makechrootpkg_flags", fallback=[])
 
-    @property
-    def cache_path(self) -> Path:
-        """
-        :return: path to cached packages
-        """
-        return self.paths.cache / self.package.base
-
-    @property
-    def git_path(self) -> Path:
-        """
-        :return: path to clone package from git
-        """
-        return self.paths.sources / self.package.base
-
-    @staticmethod
-    def fetch(local: Path, remote: str, branch: str = "master") -> None:
-        """
-        either clone repository or update it to origin/`branch`
-        :param local: local path to fetch
-        :param remote: remote target (from where to fetch)
-        :param branch: branch name to checkout, master by default
-        """
-        logger = logging.getLogger("build_details")
-        # local directory exists and there is .git directory
-        if (local / ".git").is_dir():
-            Task._check_output("git", "fetch", "origin", branch, exception=None, cwd=local, logger=logger)
-        else:
-            Task._check_output("git", "clone", remote, str(local), exception=None, logger=logger)
-        # and now force reset to our branch
-        Task._check_output("git", "checkout", "--force", branch, exception=None, cwd=local, logger=logger)
-        Task._check_output("git", "reset", "--hard", f"origin/{branch}", exception=None, cwd=local, logger=logger)
-
-    def build(self) -> List[Path]:
+    def build(self, sources_path: Path) -> List[Path]:
         """
         run package build
+        :param sources_path: path to where sources are
         :return: paths of produced packages
         """
         command = [self.build_command, "-r", str(self.paths.chroot)]
@@ -104,23 +77,24 @@ class Task:
         Task._check_output(
             *command,
             exception=BuildFailed(self.package.base),
-            cwd=self.git_path,
-            logger=self.build_logger)
+            cwd=sources_path,
+            logger=self.build_logger,
+            user=self.uid)
 
         # well it is not actually correct, but we can deal with it
         packages = Task._check_output("makepkg", "--packagelist",
                                       exception=BuildFailed(self.package.base),
-                                      cwd=self.git_path,
+                                      cwd=sources_path,
                                       logger=self.build_logger).splitlines()
         return [Path(package) for package in packages]
 
-    def init(self, path: Optional[Path] = None) -> None:
+    def init(self, path: Path, database: SQLite) -> None:
         """
         fetch package from git
-        :param path: optional local path to fetch. If not set default path will be used
+        :param path: local path to fetch
+        :param database: database instance
         """
-        git_path = path or self.git_path
-        if self.cache_path.is_dir():
+        if self.paths.cache_for(self.package.base).is_dir():
             # no need to clone whole repository, just copy from cache first
-            shutil.copytree(self.cache_path, git_path)
-        return self.fetch(git_path, self.package.git_url)
+            shutil.copytree(self.paths.cache_for(self.package.base), path, dirs_exist_ok=True)
+        Sources.load(path, self.package.git_url, database.patches_get(self.package.base))

src/ahriman/core/configuration.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -21,12 +21,14 @@ from __future__ import annotations
 
 import configparser
 import logging
+import sys
 
 from logging.config import fileConfig
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Type
+from typing import Any, Dict, Generator, List, Optional, Tuple, Type
 
 from ahriman.core.exceptions import InitializeException
+from ahriman.models.repository_paths import RepositoryPaths
 
 
 class Configuration(configparser.RawConfigParser):
@@ -37,19 +39,21 @@ class Configuration(configparser.RawConfigParser):
     :cvar ARCHITECTURE_SPECIFIC_SECTIONS: known sections which can be architecture specific (required by dump)
     :cvar DEFAULT_LOG_FORMAT: default log format (in case of fallback)
     :cvar DEFAULT_LOG_LEVEL: default log level (in case of fallback)
+    :cvar SYSTEM_CONFIGURATION_PATH: default system configuration path distributed by package
     """
 
-    DEFAULT_LOG_FORMAT = "[%(levelname)s %(asctime)s] [%(filename)s:%(lineno)d] [%(funcName)s]: %(message)s"
+    DEFAULT_LOG_FORMAT = "[%(levelname)s %(asctime)s] [%(filename)s:%(lineno)d %(funcName)s]: %(message)s"
     DEFAULT_LOG_LEVEL = logging.DEBUG
 
-    ARCHITECTURE_SPECIFIC_SECTIONS = ["build", "html", "rsync", "s3", "sign", "web"]
+    ARCHITECTURE_SPECIFIC_SECTIONS = ["build", "sign", "web"]
+    SYSTEM_CONFIGURATION_PATH = Path(sys.prefix) / "share" / "ahriman" / "settings" / "ahriman.ini"
 
     def __init__(self) -> None:
         """
         default constructor. In the most cases must not be called directly
         """
         configparser.RawConfigParser.__init__(self, allow_no_value=True, converters={
-            "list": lambda value: value.split(),
+            "list": self.__convert_list,
             "path": self.__convert_path,
         })
         self.architecture: Optional[str] = None
@@ -69,21 +73,55 @@ class Configuration(configparser.RawConfigParser):
         """
         return self.getpath("settings", "logging")
 
+    @property
+    def repository_paths(self) -> RepositoryPaths:
+        """
+        :return: repository paths instance
+        """
+        _, architecture = self.check_loaded()
+        return RepositoryPaths(self.getpath("repository", "root"), architecture)
+
     @classmethod
-    def from_path(cls: Type[Configuration], path: Path, architecture: str, logfile: bool) -> Configuration:
+    def from_path(cls: Type[Configuration], path: Path, architecture: str, quiet: bool) -> Configuration:
         """
         constructor with full object initialization
         :param path: path to root configuration file
         :param architecture: repository architecture
-        :param logfile: use log file to output messages
+        :param quiet: force disable any log messages
         :return: configuration instance
         """
         config = cls()
         config.load(path)
         config.merge_sections(architecture)
-        config.load_logging(logfile)
+        config.load_logging(quiet)
         return config
 
+    @staticmethod
+    def __convert_list(value: str) -> List[str]:
+        """
+        convert string value to list of strings
+        :param value: string configuration value
+        :return: list of string from the parsed string
+        """
+        def generator() -> Generator[str, None, None]:
+            quote_mark = None
+            word = ""
+            for char in value:
+                if char in ("'", "\"") and quote_mark is None:  # quoted part started, store quote and do nothing
+                    quote_mark = char
+                elif char == quote_mark:  # quoted part ended, reset quotation
+                    quote_mark = None
+                elif char == " " and quote_mark is None:  # found space outside of the quotation, yield the word
+                    yield word
+                    word = ""
+                else:  # append character to the buffer
+                    word += char
+            if quote_mark:  # there is unmatched quote
+                raise ValueError(f"unmatched quote in {value}")
+            yield word  # sequence done, return whatever we found
+
+        return [word for word in generator() if word]
+
     @staticmethod
     def section_name(section: str, suffix: str) -> str:
         """
@@ -105,6 +143,15 @@ class Configuration(configparser.RawConfigParser):
             return path
         return self.path.parent / path
 
+    def check_loaded(self) -> Tuple[Path, str]:
+        """
+        check if service was actually loaded
+        :return: configuration root path and architecture if loaded
+        """
+        if self.path is None or self.architecture is None:
+            raise InitializeException("Configuration path and/or architecture are not set")
+        return self.path, self.architecture
+
     def dump(self) -> Dict[str, Dict[str, str]]:
         """
         dump configuration to dictionary
@@ -121,11 +168,33 @@ class Configuration(configparser.RawConfigParser):
 
     def getpath(self, *args: Any, **kwargs: Any) -> Path: ...
 
+    def gettype(self, section: str, architecture: str) -> Tuple[str, str]:
+        """
+        get type variable with fallback to old logic
+        Despite the fact that it has same semantics as other get* methods, but it has different argument list
+        :param section: section name
+        :param architecture: repository architecture
+        :return: section name and found type name
+        """
+        group_type = self.get(section, "type", fallback=None)  # new-style logic
+        if group_type is not None:
+            return section, group_type
+        # okay lets check for the section with architecture name
+        full_section = self.section_name(section, architecture)
+        if self.has_section(full_section):
+            return full_section, section
+        # okay lets just use section as type
+        if not self.has_section(section):
+            raise configparser.NoSectionError(section)
+        return section, section
+
     def load(self, path: Path) -> None:
         """
         fully load configuration
         :param path: path to root configuration file
         """
+        if not path.is_file():  # fallback to the system file
+            path = self.SYSTEM_CONFIGURATION_PATH
         self.path = path
         self.read(self.path)
         self.load_includes()
@@ -142,27 +211,20 @@ class Configuration(configparser.RawConfigParser):
         except (FileNotFoundError, configparser.NoOptionError, configparser.NoSectionError):
             pass
 
-    def load_logging(self, logfile: bool) -> None:
+    def load_logging(self, quiet: bool) -> None:
         """
         setup logging settings from configuration
-        :param logfile: use log file to output messages
+        :param quiet: force disable any log messages
         """
-        def file_logger() -> None:
-            try:
-                path = self.logging_path
-                fileConfig(path)
-            except (FileNotFoundError, PermissionError):
-                console_logger()
-                logging.exception("could not create logfile, fallback to stderr")
-
-        def console_logger() -> None:
+        try:
+            path = self.logging_path
+            fileConfig(path)
+        except Exception:
             logging.basicConfig(filename=None, format=self.DEFAULT_LOG_FORMAT,
                                 level=self.DEFAULT_LOG_LEVEL)
-
-        if logfile:
-            file_logger()
-        else:
-            console_logger()
+            logging.exception("could not load logging from configuration, fallback to stderr")
+        if quiet:
+            logging.disable(logging.WARNING)  # only print errors here
 
     def merge_sections(self, architecture: str) -> None:
         """
@@ -189,10 +251,11 @@ class Configuration(configparser.RawConfigParser):
         """
         reload configuration if possible or raise exception otherwise
         """
-        if self.path is None or self.architecture is None:
-            raise InitializeException("Configuration path and/or architecture are not set")
-        self.load(self.path)
-        self.merge_sections(self.architecture)
+        path, architecture = self.check_loaded()
+        for section in self.sections():  # clear current content
+            self.remove_section(section)
+        self.load(path)
+        self.merge_sections(architecture)
 
     def set_option(self, section: str, option: str, value: Optional[str]) -> None:
         """

src/ahriman/core/database/__init__.py

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#

src/ahriman/core/database/data/__init__.py

@@ -0,0 +1,43 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from sqlite3 import Connection
+
+from ahriman.core.configuration import Configuration
+from ahriman.core.database.data.patches import migrate_patches
+from ahriman.core.database.data.users import migrate_users_data
+from ahriman.core.database.data.package_statuses import migrate_package_statuses
+from ahriman.models.migration_result import MigrationResult
+from ahriman.models.repository_paths import RepositoryPaths
+
+
+def migrate_data(result: MigrationResult, connection: Connection,
+                 configuration: Configuration, paths: RepositoryPaths) -> None:
+    """
+    perform data migration
+    :param result: result of the schema migration
+    :param connection: database connection
+    :param configuration: configuration instance
+    :param paths: repository paths instance
+    """
+    # initial data migration
+    if result.old_version == 0:
+        migrate_package_statuses(connection, paths)
+        migrate_users_data(connection, configuration)
+        migrate_patches(connection, paths)

src/ahriman/core/database/data/package_statuses.py

@@ -0,0 +1,80 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import json
+
+from sqlite3 import Connection
+
+from ahriman.models.build_status import BuildStatus
+from ahriman.models.package import Package
+from ahriman.models.repository_paths import RepositoryPaths
+
+
+def migrate_package_statuses(connection: Connection, paths: RepositoryPaths) -> None:
+    """
+    perform migration for package statuses
+    :param connection: database connection
+    :param paths: repository paths instance
+    """
+    def insert_base(metadata: Package, last_status: BuildStatus) -> None:
+        connection.execute(
+            """
+            insert into package_bases
+            (package_base, version, aur_url)
+            values
+            (:package_base, :version, :aur_url)
+            """,
+            dict(package_base=metadata.base, version=metadata.version, aur_url=metadata.aur_url))
+        connection.execute(
+            """
+            insert into package_statuses
+            (package_base, status, last_updated)
+            values
+            (:package_base, :status, :last_updated)""",
+            dict(package_base=metadata.base, status=last_status.status.value, last_updated=last_status.timestamp))
+
+    def insert_packages(metadata: Package) -> None:
+        package_list = []
+        for name, description in metadata.packages.items():
+            package_list.append(dict(package=name, package_base=metadata.base, **description.view()))
+        connection.executemany(
+            """
+            insert into packages
+            (package, package_base, architecture, archive_size, build_date, depends, description,
+            filename, "groups", installed_size, licenses, provides, url)
+            values
+            (:package, :package_base, :architecture, :archive_size, :build_date, :depends, :description,
+            :filename, :groups, :installed_size, :licenses, :provides, :url)
+            """,
+            package_list)
+
+    cache_path = paths.root / "status_cache.json"
+    if not cache_path.is_file():
+        return  # no file found
+    with cache_path.open() as cache:
+        dump = json.load(cache)
+
+    for item in dump.get("packages", []):
+        package = Package.from_json(item["package"])
+        status = BuildStatus.from_json(item["status"])
+        insert_base(package, status)
+        insert_packages(package)
+
+    connection.commit()
+    cache_path.unlink()

src/ahriman/core/database/data/patches.py

@@ -0,0 +1,44 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from sqlite3 import Connection
+
+from ahriman.models.repository_paths import RepositoryPaths
+
+
+def migrate_patches(connection: Connection, paths: RepositoryPaths) -> None:
+    """
+    perform migration for patches
+    :param connection: database connection
+    :param paths: repository paths instance
+    """
+    root = paths.root / "patches"
+    if not root.is_dir():
+        return  # no directory found
+
+    for package in root.iterdir():
+        patch_path = package / "00-main.patch"
+        if not patch_path.is_file():
+            continue  # not exist
+        content = patch_path.read_text(encoding="utf8")
+        connection.execute(
+            """insert into patches (package_base, patch) values (:package_base, :patch)""",
+            {"package_base": package.name, "patch": content})
+
+    connection.commit()

src/ahriman/core/database/data/users.py

@@ -0,0 +1,40 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from sqlite3 import Connection
+
+from ahriman.core.configuration import Configuration
+
+
+def migrate_users_data(connection: Connection, configuration: Configuration) -> None:
+    """
+    perform migration for users
+    :param connection: database connection
+    :param configuration: configuration instance
+    """
+    for section in configuration.sections():
+        for option, value in configuration[section].items():
+            if not section.startswith("auth:"):
+                continue
+            permission = section[5:]
+            connection.execute(
+                """insert into users (username, permission, password) values (:username, :permission, :password)""",
+                {"username": option.lower(), "permission": permission, "password": value})
+
+    connection.commit()

src/ahriman/core/database/migrations/__init__.py

@@ -0,0 +1,125 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import annotations
+
+import logging
+
+from importlib import import_module
+from pathlib import Path
+from pkgutil import iter_modules
+from sqlite3 import Connection
+from typing import List, Type
+
+from ahriman.models.migration import Migration
+from ahriman.models.migration_result import MigrationResult
+
+
+class Migrations:
+    """
+    simple migration wrapper for the sqlite
+    idea comes from https://www.ash.dev/blog/simple-migration-system-in-sqlite/
+    :ivar connection: database connection
+    :ivar logger: class logger
+    """
+
+    def __init__(self, connection: Connection) -> None:
+        """
+        default constructor
+        :param connection: database connection
+        """
+        self.connection = connection
+        self.logger = logging.getLogger("database")
+
+    @classmethod
+    def migrate(cls: Type[Migrations], connection: Connection) -> MigrationResult:
+        """
+        perform migrations implicitly
+        :param connection: database connection
+        :return: current schema version
+        """
+        return cls(connection).run()
+
+    def migrations(self) -> List[Migration]:
+        """
+        extract all migrations from the current package
+        idea comes from https://julienharbulot.com/python-dynamical-import.html
+
+        """
+        migrations: List[Migration] = []
+        package_dir = Path(__file__).resolve().parent
+        modules = [module_name for (_, module_name, _) in iter_modules([str(package_dir)])]
+
+        for index, module_name in enumerate(sorted(modules)):
+            module = import_module(f"{__name__}.{module_name}")
+            steps: List[str] = getattr(module, "steps", [])
+            self.logger.debug("found migration %s at index %s with steps count %s", module_name, index, len(steps))
+            migrations.append(Migration(index, module_name, steps))
+
+        return migrations
+
+    def run(self) -> MigrationResult:
+        """
+        perform migrations
+        :return: current schema version
+        """
+        migrations = self.migrations()
+        current_version = self.user_version()
+        expected_version = len(migrations)
+        result = MigrationResult(current_version, expected_version)
+
+        if not result.is_outdated:
+            self.logger.info("no migrations required")
+            return result
+
+        previous_isolation = self.connection.isolation_level
+        try:
+            self.connection.isolation_level = None
+            cursor = self.connection.cursor()
+            try:
+                cursor.execute("begin exclusive")
+                for migration in migrations[current_version:]:
+                    self.logger.info("applying migration %s at index %s", migration.name, migration.index)
+                    for statement in migration.steps:
+                        cursor.execute(statement)
+                    self.logger.info("migration %s at index %s has been applied", migration.name, migration.index)
+
+                cursor.execute(f"pragma user_version = {expected_version}")  # no support for ? placeholders
+            except Exception:
+                self.logger.exception("migration failed with exception")
+                cursor.execute("rollback")
+                raise
+            else:
+                cursor.execute("commit")
+            finally:
+                cursor.close()
+        finally:
+            self.connection.isolation_level = previous_isolation
+
+        self.logger.info("migrations have been performed from version %s to %s", result.old_version, result.new_version)
+        return result
+
+    def user_version(self) -> int:
+        """
+        get schema version from sqlite database
+        ;return: current schema version
+        """
+        cursor = self.connection.execute("pragma user_version")
+        current_version: int = cursor.fetchone()["user_version"]
+        return current_version

src/ahriman/core/database/migrations/m000_initial.py

@@ -0,0 +1,73 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+
+steps = [
+    """
+    create table build_queue (
+        package_base text not null unique,
+        properties json not null
+    )
+    """,
+    """
+    create table package_bases (
+        package_base text not null unique,
+        version text not null,
+        aur_url text not null
+    )
+    """,
+    """
+    create table package_statuses (
+        package_base text not null unique,
+        status text not null,
+        last_updated integer
+    )
+    """,
+    """
+    create table packages (
+        package text not null,
+        package_base text not null,
+        architecture text,
+        archive_size integer,
+        build_date integer,
+        depends json,
+        description text,
+        filename text,
+        "groups" json,
+        installed_size integer,
+        licenses json,
+        provides json,
+        url text,
+        unique (package, architecture)
+    )
+    """,
+    """
+    create table patches (
+        package_base text not null unique,
+        patch blob not null
+    )
+    """,
+    """
+    create table users (
+        username text not null unique,
+        access text not null,
+        password text
+    )
+    """,
+]

src/ahriman/core/database/operations/__init__.py

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#

src/ahriman/core/database/operations/auth_operations.py

@@ -0,0 +1,93 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import annotations
+
+from sqlite3 import Connection
+from typing import List, Optional
+
+from ahriman.core.database.operations.operations import Operations
+from ahriman.models.user import User
+from ahriman.models.user_access import UserAccess
+
+
+class AuthOperations(Operations):
+    """
+    authorization operations
+    """
+
+    def user_get(self, username: str) -> Optional[User]:
+        """
+        get user by username
+        :param username: username
+        :return: user if it was found
+        """
+        return next(iter(self.user_list(username, None)), None)
+
+    def user_list(self, username: Optional[str], access: Optional[UserAccess]) -> List[User]:
+        """
+        get users by filter
+        :param username: optional filter by username
+        :param access: optional filter by role
+        :return: list of users who match criteria
+        """
+        username_filter = username.lower() if username is not None else username
+        access_filter = access.value if access is not None else access
+
+        def run(connection: Connection) -> List[User]:
+            return [
+                User(cursor["username"], cursor["password"], UserAccess(cursor["access"]))
+                for cursor in connection.execute(
+                    """
+                    select * from users
+                    where (:username is null or username = :username) and (:access is null or access = :access)
+                    """,
+                    {"username": username_filter, "access": access_filter})
+            ]
+
+        return self.with_connection(run)
+
+    def user_remove(self, username: str) -> None:
+        """
+        remove user from storage
+        :param username: username
+        """
+        def run(connection: Connection) -> None:
+            connection.execute("""delete from users where username = :username""", {"username": username.lower()})
+
+        return self.with_connection(run, commit=True)
+
+    def user_update(self, user: User) -> None:
+        """
+        get user by username
+        :param user: user descriptor
+        """
+        def run(connection: Connection) -> None:
+            connection.execute(
+                """
+                insert into users
+                (username, access, password)
+                values
+                (:username, :access, :password)
+                on conflict (username) do update set
+                access = :access, password = :password
+                """,
+                {"username": user.username.lower(), "access": user.access.value, "password": user.password})
+
+        self.with_connection(run, commit=True)

src/ahriman/core/database/operations/build_operations.py

@@ -0,0 +1,77 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from sqlite3 import Connection
+from typing import List, Optional
+
+from ahriman.core.database.operations.operations import Operations
+from ahriman.models.package import Package
+
+
+class BuildOperations(Operations):
+    """
+    operations for main functions
+    """
+
+    def build_queue_clear(self, package_base: Optional[str]) -> None:
+        """
+        remove packages from build queue
+        :param package_base: optional filter by package base
+        """
+        def run(connection: Connection) -> None:
+            connection.execute(
+                """
+                delete from build_queue
+                where :package_base is null or package_base = :package_base
+                """,
+                {"package_base": package_base})
+
+        return self.with_connection(run, commit=True)
+
+    def build_queue_get(self) -> List[Package]:
+        """
+        retrieve packages from build queue
+        :return: list of packages to be built
+        """
+        def run(connection: Connection) -> List[Package]:
+            return [
+                Package.from_json(row["properties"])
+                for row in connection.execute("""select * from build_queue""")
+            ]
+
+        return self.with_connection(run)
+
+    def build_queue_insert(self, package: Package) -> None:
+        """
+        insert packages to build queue
+        :param package: package to be inserted
+        """
+        def run(connection: Connection) -> None:
+            connection.execute(
+                """
+                insert into build_queue
+                (package_base, properties)
+                values
+                (:package_base, :properties)
+                on conflict (package_base) do update set
+                properties = :properties
+                """,
+                {"package_base": package.base, "properties": package.view()})
+
+        return self.with_connection(run, commit=True)

src/ahriman/core/database/operations/operations.py

@@ -0,0 +1,71 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+import logging
+import sqlite3
+
+from pathlib import Path
+from sqlite3 import Connection, Cursor
+from typing import Any, Dict, Tuple, TypeVar, Callable
+
+
+T = TypeVar("T")
+
+
+class Operations:
+    """
+    base operation class
+    :ivar logger: class logger
+    :ivar path: path to the database file
+    """
+
+    def __init__(self, path: Path) -> None:
+        """
+        default constructor
+        :param path: path to the database file
+        """
+        self.path = path
+        self.logger = logging.getLogger("database")
+
+    @staticmethod
+    def factory(cursor: Cursor, row: Tuple[Any, ...]) -> Dict[str, Any]:
+        """
+        dictionary factory based on official documentation
+        :param cursor: cursor descriptor
+        :param row: fetched row
+        :return: row converted to dictionary
+        """
+        result = {}
+        for index, column in enumerate(cursor.description):
+            result[column[0]] = row[index]
+        return result
+
+    def with_connection(self, query: Callable[[Connection], T], commit: bool = False) -> T:
+        """
+        perform operation in connection
+        :param query: function to be called with connection
+        :param commit: if True commit() will be called on success
+        :return: result of the `query` call
+        """
+        with sqlite3.connect(self.path, detect_types=sqlite3.PARSE_DECLTYPES) as connection:
+            connection.row_factory = self.factory
+            result = query(connection)
+            if commit:
+                connection.commit()
+        return result

src/ahriman/core/database/operations/package_operations.py

@@ -0,0 +1,199 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from sqlite3 import Connection
+from typing import Dict, Generator, Iterable, List, Tuple
+
+from ahriman.core.database.operations.operations import Operations
+from ahriman.models.build_status import BuildStatus
+from ahriman.models.package import Package
+from ahriman.models.package_description import PackageDescription
+
+
+class PackageOperations(Operations):
+    """
+    package operations
+    """
+
+    @staticmethod
+    def _package_remove_package_base(connection: Connection, package_base: str) -> None:
+        """
+        remove package base information
+        :param connection: database connection
+        :param package_base: package base name
+        """
+        connection.execute("""delete from package_statuses where package_base = :package_base""",
+                           {"package_base": package_base})
+        connection.execute("""delete from package_bases where package_base = :package_base""",
+                           {"package_base": package_base})
+
+    @staticmethod
+    def _package_remove_packages(connection: Connection, package_base: str, current_packages: Iterable[str]) -> None:
+        """
+        remove packages belong to the package base
+        :param connection: database connection
+        :param package_base: package base name
+        :param current_packages: current packages list which has to be left in database
+        """
+        packages = [
+            package
+            for package in connection.execute(
+                """select package from packages where package_base = :package_base""", {"package_base": package_base})
+            if package["package"] not in current_packages
+        ]
+        connection.executemany("""delete from packages where package = :package""", packages)
+
+    @staticmethod
+    def _package_update_insert_base(connection: Connection, package: Package) -> None:
+        """
+        insert base package into table
+        :param connection: database connection
+        :param package: package properties
+        """
+        connection.execute(
+            """
+            insert into package_bases
+            (package_base, version, aur_url)
+            values
+            (:package_base, :version, :aur_url)
+            on conflict (package_base) do update set
+            version = :version, aur_url = :aur_url
+            """,
+            dict(package_base=package.base, version=package.version, aur_url=package.aur_url))
+
+    @staticmethod
+    def _package_update_insert_packages(connection: Connection, package: Package) -> None:
+        """
+        insert packages into table
+        :param connection: database connection
+        :param package: package properties
+        """
+        package_list = []
+        for name, description in package.packages.items():
+            package_list.append(dict(package=name, package_base=package.base, **description.view()))
+        connection.executemany(
+            """
+            insert into packages
+            (package, package_base, architecture, archive_size,
+            build_date, depends, description, filename,
+            "groups", installed_size, licenses, provides, url)
+            values
+            (:package, :package_base, :architecture, :archive_size,
+            :build_date, :depends, :description, :filename,
+            :groups, :installed_size, :licenses, :provides, :url)
+            on conflict (package, architecture) do update set
+            package_base = :package_base, archive_size = :archive_size,
+            build_date = :build_date, depends = :depends, description = :description, filename = :filename,
+            "groups" = :groups, installed_size = :installed_size, licenses = :licenses, provides = :provides, url = :url
+            """,
+            package_list)
+
+    @staticmethod
+    def _package_update_insert_status(connection: Connection, package_base: str, status: BuildStatus) -> None:
+        """
+        insert base package status into table
+        :param connection: database connection
+        :param package_base: package base name
+        :param status: new build status
+        """
+        connection.execute(
+            """
+            insert into package_statuses (package_base, status, last_updated)
+            values
+            (:package_base, :status, :last_updated)
+            on conflict (package_base) do update set
+            status = :status, last_updated = :last_updated
+            """,
+            dict(package_base=package_base, status=status.status.value, last_updated=status.timestamp))
+
+    @staticmethod
+    def _packages_get_select_package_bases(connection: Connection) -> Dict[str, Package]:
+        """
+        select package bases from the table
+        :param connection: database connection
+        :return: map of the package base to its descriptor (without packages themselves)
+        """
+        return {
+            row["package_base"]: Package(row["package_base"], row["version"], row["aur_url"], {})
+            for row in connection.execute("""select * from package_bases""")
+        }
+
+    @staticmethod
+    def _packages_get_select_packages(connection: Connection, packages: Dict[str, Package]) -> Dict[str, Package]:
+        """
+        select packages from the table
+        :param connection: database connection
+        :param packages: packages descriptor map
+        :return: map of the package base to its descriptor including individual packages
+        """
+        for row in connection.execute("""select * from packages"""):
+            if row["package_base"] not in packages:
+                continue  # normally must never happen though
+            packages[row["package_base"]].packages[row["package"]] = PackageDescription.from_json(row)
+        return packages
+
+    @staticmethod
+    def _packages_get_select_statuses(connection: Connection) -> Dict[str, BuildStatus]:
+        """
+        select package build statuses from the table
+        :param connection: database connection
+        :return: map of the package base to its status
+        """
+        return {
+            row["package_base"]: BuildStatus.from_json({"status": row["status"], "timestamp": row["last_updated"]})
+            for row in connection.execute("""select * from package_statuses""")
+        }
+
+    def package_remove(self, package_base: str) -> None:
+        """
+        remove package from database
+        :param package_base: package base name
+        """
+        def run(connection: Connection) -> None:
+            self._package_remove_packages(connection, package_base, [])
+            self._package_remove_package_base(connection, package_base)
+
+        return self.with_connection(run, commit=True)
+
+    def package_update(self, package: Package, status: BuildStatus) -> None:
+        """
+        update package status
+        :param package: package properties
+        :param status: new build status
+        """
+        def run(connection: Connection) -> None:
+            self._package_update_insert_base(connection, package)
+            self._package_update_insert_status(connection, package.base, status)
+            self._package_update_insert_packages(connection, package)
+            self._package_remove_packages(connection, package.base, package.packages.keys())
+
+        return self.with_connection(run, commit=True)
+
+    def packages_get(self) -> List[Tuple[Package, BuildStatus]]:
+        """
+        get package list and their build statuses from database
+        :return: list of package properties and their statuses
+        """
+        def run(connection: Connection) -> Generator[Tuple[Package, BuildStatus], None, None]:
+            packages = self._packages_get_select_package_bases(connection)
+            statuses = self._packages_get_select_statuses(connection)
+            for package_base, package in self._packages_get_select_packages(connection, packages).items():
+                yield package, statuses.get(package_base, BuildStatus())
+
+        return self.with_connection(lambda connection: list(run(connection)))

src/ahriman/core/database/operations/patch_operations.py

@@ -0,0 +1,85 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from sqlite3 import Connection
+from typing import Dict, Optional
+
+from ahriman.core.database.operations.operations import Operations
+
+
+class PatchOperations(Operations):
+    """
+    operations for patches
+    """
+
+    def patches_get(self, package_base: str) -> Optional[str]:
+        """
+        retrieve patches for the package
+        :param package_base: package base to search for patches
+        :return: plain text patch for the package
+        """
+        return self.patches_list(package_base).get(package_base)
+
+    def patches_insert(self, package_base: str, patch: str) -> None:
+        """
+        insert or update patch in database
+        :param package_base: package base to insert
+        :param patch: patch content
+        """
+        def run(connection: Connection) -> None:
+            connection.execute(
+                """
+                insert into patches
+                (package_base, patch)
+                values
+                (:package_base, :patch)
+                on conflict (package_base) do update set
+                patch = :patch
+                """,
+                {"package_base": package_base, "patch": patch})
+
+        return self.with_connection(run, commit=True)
+
+    def patches_list(self, package_base: Optional[str]) -> Dict[str, str]:
+        """
+        extract all patches
+        :param package_base: optional filter by package base
+        :return: map of package base to patch content
+        """
+        def run(connection: Connection) -> Dict[str, str]:
+            return {
+                cursor["package_base"]: cursor["patch"]
+                for cursor in connection.execute(
+                    """select * from patches where :package_base is null or package_base = :package_base""",
+                    {"package_base": package_base})
+            }
+
+        return self.with_connection(run)
+
+    def patches_remove(self, package_base: str) -> None:
+        """
+        remove patch set
+        :param package_base: package base to clear patches
+        """
+        def run(connection: Connection) -> None:
+            connection.execute(
+                """delete from patches where package_base = :package_base""",
+                {"package_base": package_base})
+
+        return self.with_connection(run, commit=True)

src/ahriman/core/database/sqlite.py

@@ -0,0 +1,70 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from __future__ import annotations
+
+import json
+import sqlite3
+
+from sqlite3 import Connection
+from typing import Type
+
+from ahriman.core.configuration import Configuration
+from ahriman.core.database.data import migrate_data
+from ahriman.core.database.migrations import Migrations
+from ahriman.core.database.operations.auth_operations import AuthOperations
+from ahriman.core.database.operations.build_operations import BuildOperations
+from ahriman.core.database.operations.package_operations import PackageOperations
+from ahriman.core.database.operations.patch_operations import PatchOperations
+
+
+class SQLite(AuthOperations, BuildOperations, PackageOperations, PatchOperations):
+    """
+    wrapper for sqlite3 database
+    """
+
+    @classmethod
+    def load(cls: Type[SQLite], configuration: Configuration) -> SQLite:
+        """
+        construct instance from configuration
+        :param configuration: configuration instance
+        :return: fully initialized instance of the database
+        """
+        database = cls(configuration.getpath("settings", "database"))
+        database.init(configuration)
+        return database
+
+    def init(self, configuration: Configuration) -> None:
+        """
+        perform database migrations
+        :param configuration: configuration instance
+        """
+        # custom types support
+        sqlite3.register_adapter(dict, json.dumps)
+        sqlite3.register_adapter(list, json.dumps)
+        sqlite3.register_converter("json", json.loads)
+
+        paths = configuration.repository_paths
+
+        def run(connection: Connection) -> None:
+            result = Migrations.migrate(connection)
+            migrate_data(result, connection, configuration, paths)
+
+        self.with_connection(run)
+        paths.chown(self.path)

src/ahriman/core/exceptions.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2021 ahriman team.
+# Copyright (c) 2021-2022 ahriman team.
 #
 # This file is part of ahriman
 # (see https://github.com/arcan1s/ahriman).
@@ -17,6 +17,7 @@
 # You should have received a copy of the GNU General Public License
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 #
+from pathlib import Path
 from typing import Any
 
 
@@ -25,12 +26,12 @@ class BuildFailed(RuntimeError):
     base exception for failed builds
     """
 
-    def __init__(self, package: str) -> None:
+    def __init__(self, package_base: str) -> None:
         """
         default constructor
-        :param package: package base raised exception
+        :param package_base: package base raised exception
         """
-        RuntimeError.__init__(self, f"Package {package} build failed, check logs for details")
+        RuntimeError.__init__(self, f"Package {package_base} build failed, check logs for details")
 
 
 class DuplicateRun(RuntimeError):
@@ -42,21 +43,15 @@ class DuplicateRun(RuntimeError):
         """
         default constructor
         """
-        RuntimeError.__init__(self, "Another application instance is run")
+        RuntimeError.__init__(
+            self, "Another application instance is run. This error can be suppressed by using --force flag.")
 
 
-class DuplicateUser(ValueError):
+class ExitCode(RuntimeError):
     """
-    exception which will be thrown in case if there are two users with different settings
+    special exception which has to be thrown to return non-zero status without error message
     """
 
-    def __init__(self, username: str) -> None:
-        """
-        default constructor
-        :param username: username with duplicates
-        """
-        ValueError.__init__(self, f"Found duplicate user with username {username}")
-
 
 class InitializeException(RuntimeError):
     """
@@ -71,19 +66,6 @@ class InitializeException(RuntimeError):
         RuntimeError.__init__(self, f"Could not load service: {details}")
 
 
-class InvalidCommand(ValueError):
-    """
-    exception raised on invalid command line options
-    """
-
-    def __init__(self, details: Any) -> None:
-        """
-        default constructor
-        :param details" error details
-        """
-        ValueError.__init__(self, details)
-
-
 class InvalidOption(ValueError):
     """
     exception which will be raised on configuration errors
@@ -97,6 +79,20 @@ class InvalidOption(ValueError):
         ValueError.__init__(self, f"Invalid or unknown option value `{value}`")
 
 
+class InvalidPath(ValueError):
+    """
+    exception which will be raised on path which is not belong to root directory
+    """
+
+    def __init__(self, path: Path, root: Path) -> None:
+        """
+        default constructor
+        :param path: path which raised an exception
+        :param root: repository root (i.e. ahriman home)
+        """
+        ValueError.__init__(self, f"Path `{path}` does not belong to repository root `{root}`")
+
+
 class InvalidPackageInfo(RuntimeError):
     """
     exception which will be raised on package load errors
@@ -110,6 +106,19 @@ class InvalidPackageInfo(RuntimeError):
         RuntimeError.__init__(self, f"There are errors during reading package information: `{details}`")
 
 
+class MigrationError(RuntimeError):
+    """
+    exception which will be raised on migration error
+    """
+
+    def __init__(self, details: str) -> None:
+        """
+        default constructor
+        :param details: error details
+        """
+        RuntimeError.__init__(self, details)
+
+
 class MissingArchitecture(ValueError):
     """
     exception which will be raised if architecture is required, but missing
@@ -123,7 +132,7 @@ class MissingArchitecture(ValueError):
         ValueError.__init__(self, f"Architecture required for subcommand {command}, but missing")
 
 
-class MultipleArchitecture(ValueError):
+class MultipleArchitectures(ValueError):
     """
     exception which will be raised if multiple architectures are not supported by the handler
     """
@@ -148,6 +157,19 @@ class ReportFailed(RuntimeError):
         RuntimeError.__init__(self, "Report failed")
 
 
+class SuccessFailed(ValueError):
+    """
+    exception for merging invalid statues
+    """
+
+    def __init__(self, package_base: str) -> None:
+        """
+        default constructor
+        :param package_base: package base name
+        """
+        ValueError.__init__(self, f"Package base {package_base} had status failed, but new status is success")
+
+
 class SyncFailed(RuntimeError):
     """
     remote synchronization exception
@@ -165,8 +187,12 @@ class UnknownPackage(ValueError):
     exception for status watcher which will be thrown on unknown package
     """
 
-    def __init__(self, base: str) -> None:
-        ValueError.__init__(self, f"Package base {base} is unknown")
+    def __init__(self, package_base: str) -> None:
+        """
+        default constructor
+        :param package_base: package base name
+        """
+        ValueError.__init__(self, f"Package base {package_base} is unknown")
 
 
 class UnsafeRun(RuntimeError):
@@ -177,9 +203,9 @@ class UnsafeRun(RuntimeError):
     def __init__(self, current_uid: int, root_uid: int) -> None:
         """
         default constructor
+        :param current_uid: current user ID
+        :param root_uid: ID of the owner of root directory
         """
-        RuntimeError.__init__(
-            self,
-            f"""Current UID {current_uid} differs from root owner {root_uid}.
-Note that for the most actions it is unsafe to run application as different user.
-If you are 100% sure that it must be there try --unsafe option""")
+        RuntimeError.__init__(self, f"Current UID {current_uid} differs from root owner {root_uid}. "
+                                    f"Note that for the most actions it is unsafe to run application as different user."
+                                    f" If you are 100% sure that it must be there try --unsafe option")

src/ahriman/core/formatters/__init__.py

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#

src/ahriman/core/formatters/aur_printer.py

@@ -0,0 +1,56 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from typing import List
+
+from ahriman.core.formatters.string_printer import StringPrinter
+from ahriman.core.util import pretty_datetime
+from ahriman.models.aur_package import AURPackage
+from ahriman.models.property import Property
+
+
+class AurPrinter(StringPrinter):
+    """
+    print content of the AUR package
+    :ivar package: AUR package description
+    """
+
+    def __init__(self, package: AURPackage) -> None:
+        """
+        default constructor
+        :param package: AUR package description
+        """
+        StringPrinter.__init__(self, f"{package.name} {package.version} ({package.num_votes})")
+        self.package = package
+
+    def properties(self) -> List[Property]:
+        """
+        convert content into printable data
+        :return: list of content properties
+        """
+        return [
+            Property("Package base", self.package.package_base),
+            Property("Description", self.package.description, is_required=True),
+            Property("Upstream URL", self.package.url or ""),
+            Property("Licenses", ",".join(self.package.license)),
+            Property("Maintainer", self.package.maintainer or ""),
+            Property("First submitted", pretty_datetime(self.package.first_submitted)),
+            Property("Last updated", pretty_datetime(self.package.last_modified)),
+            Property("Keywords", ",".join(self.package.keywords)),
+        ]

src/ahriman/core/formatters/build_printer.py

@@ -0,0 +1,48 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from ahriman.core.formatters.string_printer import StringPrinter
+from ahriman.models.package import Package
+
+
+class BuildPrinter(StringPrinter):
+    """
+    print content of the build result
+    """
+
+    def __init__(self, package: Package, is_success: bool, use_utf: bool) -> None:
+        """
+        default constructor
+        :param package: built package
+        :param is_success: True in case if build has success status and False otherwise
+        :param use_utf: use utf instead of normal symbols
+        """
+        StringPrinter.__init__(self, f"{self.sign(is_success, use_utf)} {package.base}")
+
+    @staticmethod
+    def sign(is_success: bool, use_utf: bool) -> str:
+        """
+        generate sign according to settings
+        :param use_utf: use utf instead of normal symbols
+        :param is_success: True in case if build has success status and False otherwise
+        :return: sign symbol according to current settings
+        """
+        if is_success:
+            return "[✔]" if use_utf else "[x]"
+        return "[❌]" if use_utf else "[ ]"

src/ahriman/core/formatters/configuration_printer.py

@@ -0,0 +1,49 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from typing import Dict, List
+
+from ahriman.core.formatters.string_printer import StringPrinter
+from ahriman.models.property import Property
+
+
+class ConfigurationPrinter(StringPrinter):
+    """
+    print content of the configuration section
+    :ivar values: configuration values dictionary
+    """
+
+    def __init__(self, section: str, values: Dict[str, str]) -> None:
+        """
+        default constructor
+        :param section: section name
+        :param values: configuration values dictionary
+        """
+        StringPrinter.__init__(self, f"[{section}]")
+        self.values = values
+
+    def properties(self) -> List[Property]:
+        """
+        convert content into printable data
+        :return: list of content properties
+        """
+        return [
+            Property(key, value, is_required=True)
+            for key, value in sorted(self.values.items())
+        ]

src/ahriman/core/formatters/package_printer.py

@@ -0,0 +1,56 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from typing import List
+
+from ahriman.core.formatters.string_printer import StringPrinter
+from ahriman.models.build_status import BuildStatus
+from ahriman.models.package import Package
+from ahriman.models.property import Property
+
+
+class PackagePrinter(StringPrinter):
+    """
+    print content of the internal package object
+    :ivar package: package description
+    :ivar status: build status
+    """
+
+    def __init__(self, package: Package, status: BuildStatus) -> None:
+        """
+        default constructor
+        :param package: package description
+        :param status: build status
+        """
+        StringPrinter.__init__(self, package.pretty_print())
+        self.package = package
+        self.status = status
+
+    def properties(self) -> List[Property]:
+        """
+        convert content into printable data
+        :return: list of content properties
+        """
+        return [
+            Property("Version", self.package.version, is_required=True),
+            Property("Groups", " ".join(self.package.groups)),
+            Property("Licenses", " ".join(self.package.licenses)),
+            Property("Depends", " ".join(self.package.depends)),
+            Property("Status", self.status.pretty_print(), is_required=True),
+        ]

src/ahriman/core/formatters/printer.py

@@ -0,0 +1,55 @@
+#
+# Copyright (c) 2021-2022 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 <http://www.gnu.org/licenses/>.
+#
+from typing import Callable, List, Optional
+
+from ahriman.models.property import Property
+
+
+class Printer:
+    """
+    base class for formatters
+    """
+
+    def print(self, verbose: bool, log_fn: Callable[[str], None] = print, separator: str = ": ") -> None:
+        """
+        print content
+        :param verbose: print all fields
+        :param log_fn: logger function to log data
+        :param separator: separator for property name and property value
+        """
+        if (title := self.title()) is not None:
+            log_fn(title)
+        for prop in self.properties():
+            if not verbose and not prop.is_required:
+                continue
+            log_fn(f"\t{prop.name}{separator}{prop.value}")
+
+    def properties(self) -> List[Property]:  # pylint: disable=no-self-use
+        """
+        convert content into printable data
+        :return: list of content properties
+        """
+        return []
+
+    def title(self) -> Optional[str]:
+        """
+        generate entry title from content
+        :return: content title if it can be generated and None otherwise
+        """