fix: update PKGBUILD to use libvieter

Reviewed-on: #360

.clang-format

@@ -0,0 +1,4 @@
+# To stay consistent with the V formatting style, we use tabs
+UseTab: Always
+IndentWidth: 4
+TabWidth: 4

.editorconfig

@@ -5,6 +5,5 @@ root = true
 end_of_line = lf
 insert_final_newline = true
 
-[*.v]
-# vfmt wants it :(
+[*.{v,c,h}]
 indent_style = tab

.gitignore

@@ -1,4 +1,4 @@
-*.c
+vieter.c
 /data/
 
 # Build artifacts
@@ -26,4 +26,8 @@ gdb.txt
 
 # Generated docs
 _docs/
+docs/resources/_gen/
 /man/
+
+# VLS logs
+vls.log

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "docs/themes/hugo-book"]
 	path = docs/themes/hugo-book
 	url = https://github.com/alex-shpak/hugo-book
+[submodule "src/libvieter"]
+	path = src/libvieter
+	url = https://git.rustybever.be/vieter-v/libvieter

.woodpecker/.lint.yml

@@ -1,13 +0,0 @@
-# These checks already get performed on the feature branches
-branches:
-  exclude: [ main ]
-platform: 'linux/amd64'
-
-pipeline:
-  lint:
-    image: 'chewingbever/vlang:latest'
-    pull: true
-    commands:
-      - make lint
-    when:
-      event: [ pull_request ]

.woodpecker/.test.yml

@@ -1,17 +0,0 @@
-matrix:
-  PLATFORM:
-    - 'linux/amd64'
-    - 'linux/arm64'
-
-branches:
-  exclude: [ main ]
-platform: ${PLATFORM}
-
-pipeline:
-  test:
-    image: 'chewingbever/vlang:latest'
-    pull: true
-    commands:
-      - make test
-    when:
-      event: [pull_request]

.woodpecker/arch-rel.yml

@@ -9,7 +9,8 @@ skip_clone: true
 
 pipeline:
   build:
-    image: 'menci/archlinuxarm:base-devel'
+    image: 'git.rustybever.be/vieter-v/vieter-builder'
+    pull: true
     commands:
       # Add the vieter repository so we can use the compiler
       - echo -e '[vieter]\nServer = https://arch.r8r.be/$repo/$arch\nSigLevel = Optional' >> /etc/pacman.conf
@@ -23,7 +24,7 @@ pipeline:
       - su builder
       # Due to a bug with the V compiler, we can't just use the PKGBUILD from
       # inside the repo
-      - curl -OL "https://git.rustybever.be/vieter/vieter/raw/tag/$CI_COMMIT_TAG/PKGBUILD"
+      - curl -OL "https://git.rustybever.be/vieter-v/vieter/raw/tag/$CI_COMMIT_TAG/PKGBUILD"
       - makepkg -s --noconfirm --needed
     when:
       event: tag

.woodpecker/arch.yml

@@ -9,7 +9,8 @@ skip_clone: true
 
 pipeline:
   build:
-    image: 'menci/archlinuxarm:base-devel'
+    image: 'git.rustybever.be/vieter-v/vieter-builder'
+    pull: true
     commands:
       # Add the vieter repository so we can use the compiler
       - echo -e '[vieter]\nServer = https://arch.r8r.be/$repo/$arch\nSigLevel = Optional' >> /etc/pacman.conf
@@ -23,7 +24,7 @@ pipeline:
       - su builder
       # Due to a bug with the V compiler, we can't just use the PKGBUILD from
       # inside the repo
-      - curl -o PKGBUILD -L https://git.rustybever.be/vieter/vieter/raw/branch/dev/PKGBUILD.dev
+      - curl -o PKGBUILD -L https://git.rustybever.be/vieter-v/vieter/raw/branch/dev/PKGBUILD.dev
       - makepkg -s --noconfirm --needed
     when:
       event: push

.woodpecker/build.yml

@@ -1,3 +1,6 @@
+variables:
+  - &vlang_image 'git.rustybever.be/vieter/vlang:5d4c9dc9fc11bf8648541c934adb64f27cb94e37-alpine3.17'
+
 matrix:
   PLATFORM:
     - 'linux/amd64'
@@ -6,10 +9,19 @@ matrix:
 platform: ${PLATFORM}
 
 pipeline:
-  debug:
-    image: 'chewingbever/vlang:latest'
+  install-modules:
+    image: *vlang_image
     pull: true
     commands:
+      - export VMODULES=$PWD/.vmodules
+      - 'cd src && v install'
+    when:
+      event: [push, pull_request]
+
+  debug:
+    image: *vlang_image
+    commands:
+      - export VMODULES=$PWD/.vmodules
       - make
     when:
       event: [pull_request]
@@ -17,11 +29,11 @@ pipeline:
         exclude: [main]
 
   prod:
-    image: 'chewingbever/vlang:latest'
-    pull: true
+    image: *vlang_image
     environment:
       - LDFLAGS=-lz -lbz2 -llzma -lexpat -lzstd -llz4 -lsqlite3 -static
     commands:
+      - export VMODULES=$PWD/.vmodules
       # Apparently this -D is *very* important
       - CFLAGS='-DGC_THREADS=1' make prod
       # Make sure the binary is actually statically built
@@ -35,7 +47,7 @@ pipeline:
       event: [push, pull_request]
 
   upload:
-    image: 'chewingbever/vlang:latest'
+    image: *vlang_image
     secrets: [ s3_username, s3_password ]
     commands:
       # https://gist.github.com/JustinTimperio/7c7115f87b775618637d67ac911e595f
@@ -45,7 +57,7 @@ pipeline:
 
       - export OBJ_PATH="/vieter/commits/$CI_COMMIT_SHA/vieter-$(echo '${PLATFORM}' | sed 's:/:-:g')"
       - export SIG_STRING="PUT\n\n$CONTENT_TYPE\n$DATE\n$OBJ_PATH"
-      - export SIGNATURE="$(echo -en $SIG_STRING | openssl sha1 -hmac $S3_PASSWORD -binary | base64)"
+      - export SIGNATURE="$(echo -en $SIG_STRING | openssl dgst -sha1 -hmac $S3_PASSWORD -binary | base64)"
       - >
         curl 
         --silent

.woodpecker/docs.yml

@@ -1,25 +1,29 @@
+variables:
+  - &vlang_image 'git.rustybever.be/vieter/vlang:5d4c9dc9fc11bf8648541c934adb64f27cb94e37-alpine3.17'
+
 platform: 'linux/amd64'
 branches:
   exclude: [ main ]
 
 pipeline:
   docs:
-    image: 'klakegg/hugo:alpine'
+    image: 'klakegg/hugo:ext-alpine'
     group: 'generate'
     commands:
       - apk add git
       - make docs
 
   api-docs:
-    image: 'chewingbever/vlang:latest'
+    image: *vlang_image
     pull: true
     group: 'generate'
     commands:
       - make api-docs
 
   slate-docs:
-    image: 'slatedocs/slate'
+    image: 'slatedocs/slate:v2.13.0'
     group: 'generate'
+    # Slate requires a specific directory to run in
     commands:
       - cd docs/api
       - bundle exec middleman build --clean

.woodpecker/gitea.yml

@@ -1,3 +1,6 @@
+variables:
+  - &vlang_image 'git.rustybever.be/vieter/vlang:5d4c9dc9fc11bf8648541c934adb64f27cb94e37-alpine3.17'
+
 platform: 'linux/amd64'
 branches: [ 'main' ]
 depends_on:
@@ -8,7 +11,7 @@ skip_clone: true
 
 pipeline:
   prepare:
-    image: 'chewingbever/vlang:latest'
+    image: *vlang_image
     pull: true
     secrets: [ s3_username, s3_password ]
     commands:

.woodpecker/lint.yml

@@ -0,0 +1,27 @@
+variables:
+  - &vlang_image 'git.rustybever.be/vieter/vlang:5d4c9dc9fc11bf8648541c934adb64f27cb94e37-alpine3.17'
+
+# These checks already get performed on the feature branches
+branches:
+  exclude: [ main ]
+platform: 'linux/amd64'
+
+pipeline:
+  # vfmt seems to get confused if these aren't present
+  install-modules:
+    image: *vlang_image
+    pull: true
+    commands:
+      - export VMODULES=$PWD/.vmodules
+      - 'cd src && v install'
+    when:
+      event: [pull_request]
+
+  lint:
+    image: *vlang_image
+    pull: true
+    commands:
+      - export VMODULES=$PWD/.vmodules
+      - make lint
+    when:
+      event: [pull_request]

.woodpecker/man.yml

@@ -1,3 +1,6 @@
+variables:
+  - &vlang_image 'git.rustybever.be/vieter/vlang:5d4c9dc9fc11bf8648541c934adb64f27cb94e37-alpine3.17'
+
 platform: 'linux/amd64'
 branches:
   exclude: [ main ]
@@ -5,15 +8,21 @@ branches:
 depends_on:
   - build
 
-skip_clone: true
-
 pipeline:
-  generate:
-    image: 'chewingbever/vlang:latest'
+  install-modules:
+    image: *vlang_image
     pull: true
     commands:
-      - curl -o vieter -L "https://s3.rustybever.be/vieter/commits/$CI_COMMIT_SHA/vieter-linux-amd64"
-      - chmod +x vieter
+      - export VMODULES=$PWD/.vmodules
+      - 'cd src && v install'
+
+  generate:
+    image: *vlang_image
+    commands:
+      # - curl -o vieter -L "https://s3.rustybever.be/vieter/commits/$CI_COMMIT_SHA/vieter-linux-amd64"
+      # - chmod +x vieter
+      - export VMODULES=$PWD/.vmodules
+      - make
       - ./vieter man man
       - cd man
 

.woodpecker/test.yml

@@ -0,0 +1,30 @@
+variables:
+  - &vlang_image 'git.rustybever.be/vieter/vlang:5d4c9dc9fc11bf8648541c934adb64f27cb94e37-alpine3.17'
+
+matrix:
+  PLATFORM:
+    - 'linux/amd64'
+    - 'linux/arm64'
+
+branches:
+  exclude: [ main ]
+platform: ${PLATFORM}
+
+pipeline:
+  install-modules:
+    image: *vlang_image
+    pull: true
+    commands:
+      - export VMODULES=$PWD/.vmodules
+      - 'cd src && v install'
+    when:
+      event: [pull_request]
+
+  test:
+    image: *vlang_image
+    pull: true
+    commands:
+      - export VMODULES=$PWD/.vmodules
+      - make test
+    when:
+      event: [pull_request]

CHANGELOG.md

@@ -5,9 +5,120 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased](https://git.rustybever.be/vieter/vieter/src/branch/dev)
+## [Unreleased](https://git.rustybever.be/vieter-v/vieter/src/branch/dev)
 
-## [0.3.0-rc.1](https://git.rustybever.be/vieter/vieter/src/tag/0.3.0-rc.1)
+## [0.6.0](https://git.rustybever.be/vieter-v/vieter/src/tag/0.6.0)
+
+### Added
+
+* Metrics endpoint for Prometheus integration
+* Search in list of targets using API & CLI
+* Allow filtering targets by arch value
+* Configurable global timeout for builds
+
+### Changed
+
+* Rewrote cron expression logic in C
+* Updated codebase to V commit after 0.3.3
+* Agents now use worker threads and no longer spawn a new thread for every
+  build
+
+### Fixed
+
+* Package upload now fails if TCP connection is closed before all bytes have
+  been received
+
+### Removed
+
+* Deprecated cron daemon
+
+## [0.5.0](https://git.rustybever.be/vieter-v/vieter/src/tag/0.5.0)
+
+### Added
+
+* CLI commands for removing packages, arch-repos & repositories
+
+## [0.5.0-rc.2](https://git.rustybever.be/vieter-v/vieter/src/tag/0.5.0-rc.2)
+
+### Added
+
+* API route for removing logs & accompanying CLI command
+* Daemon for periodically removing old logs
+* CLI flag to filter logs by specific exit codes
+
+### Changed
+
+* Use `--long-option` instead of `-long-option` for CLI
+
+## [0.5.0-rc.1](https://git.rustybever.be/vieter-v/vieter/src/tag/0.5.0-rc.1)
+
+### Added
+
+* Allow specifying subdirectory inside Git repository
+* Added option to deploy using agent-server architecture instead of cron daemon
+* Allow scheduling builds on the server from the CLI tool instead of building
+  them locally
+* Allow force-building packages, meaning the build won't check if the
+  repository is already up to date
+
+### Changed
+
+* Migrated codebase to V 0.3.2
+* Cron expression parser now uses bitfields instead of bool arrays
+
+### Fixed
+
+* Arch value for target is now properly set if not provided
+* Allow NULL values for branch in database
+* Endpoint for adding targets now returns the correct id
+* CLI now correctly errors and doesn't error when sending requests
+* Fixed possible infinite loop when removing old build images
+* Check whether build image still exists before starting build
+* Don't run makepkg `prepare()` function twice
+* Don't buffer stdout in Docker containers
+
+## [0.4.0](https://git.rustybever.be/vieter-v/vieter/src/tag/0.4.0)
+
+### Added
+
+* Server port can now be configured
+* Targets now have a 'kind' field describing whether it's a Git repository or a
+  URL to a PKGBUILD
+* Targets with kind 'url' can provide a direct URL to a PKGBUILD instead of
+  providing a Git repository
+* CLI commands for searching the AUR & directly adding packages
+* HTTP routes for removing packages, arch-repos & repos
+* All endpoints serving files now support HTTP byte range requests
+* Better CLI UX
+    * When adding targets, the ID of the created target is returned
+    * The `-r` flag only shows raw data of action
+        * When adding a target, only ID is shown and not surrounding text
+        * Tabled output returns a tab-separated list (easy to script using
+          `cut`)
+
+### Changed
+
+* Moved all API routes under `/v1` namespace
+* Renamed `vieter repos` to `vieter targets`
+* Renamed `/api/v1/repos` namespace to `/api/v1/targets`
+* Branch name for 'git' targets is now optional; if not provided, the
+  repository will be cloned with the default branch
+* Build containers now explicitely set the PATH variable
+* Refactor of web framework
+* API endpoints now return id of newly created entries
+* Repo POST requests now return information on published package
+* `api` can no longer be used as a repository name
+* CLI client now allows setting values to an empty value
+
+### Removed
+
+* md5 hashes are no longer calculated for packages
+
+## [0.3.0](https://git.rustybever.be/vieter-v/vieter/src/tag/0.3.0)
+
+Nothing besides bumping the versions.
+
+## [0.3.0-rc.1](https://git.rustybever.be/vieter-v/vieter/src/tag/0.3.0-rc.1)
 
 ### Added
 
@@ -35,7 +146,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * `POST /api/logs` now correctly uses epoch timestamps instead of strings
 
-## [0.3.0-alpha.2](https://git.rustybever.be/vieter/vieter/src/tag/0.3.0-alpha.2)
+## [0.3.0-alpha.2](https://git.rustybever.be/vieter-v/vieter/src/tag/0.3.0-alpha.2)
 
 ### Added
 
@@ -60,7 +171,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
     * `vieter-git` is the latest commit on the dev branch
 * Full refactor of Docker socket code
 
-## [0.3.0-alpha.1](https://git.rustybever.be/vieter/vieter/src/tag/0.3.0-alpha.1)
+## [0.3.0-alpha.1](https://git.rustybever.be/vieter-v/vieter/src/tag/0.3.0-alpha.1)
 
 ### Changed
 
@@ -79,7 +190,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Binary no longer panics when an env var is missing
 
-## [0.2.0](https://git.rustybever.be/vieter/vieter/src/tag/0.2.0)
+## [0.2.0](https://git.rustybever.be/vieter-v/vieter/src/tag/0.2.0)
 
 ### Changed
 
@@ -113,13 +224,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Packages with unknown fields in .PKGINFO are now allowed
 * Old packages are now properly removed
 
-## [0.1.0](https://git.rustybever.be/vieter/vieter/src/tag/0.1.0)
+## [0.1.0](https://git.rustybever.be/vieter-v/vieter/src/tag/0.1.0)
 
 ### Changed
 
 * Improved logging
 
-## [0.1.0-rc.1](https://git.rustybever.be/vieter/vieter/src/tag/0.1.0-rc.1)
+## [0.1.0-rc.1](https://git.rustybever.be/vieter-v/vieter/src/tag/0.1.0-rc.1)
 
 ### Added
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM chewingbever/vlang:latest AS builder
+FROM git.rustybever.be/chewing_bever/vlang:0.3.2 AS builder
 
 ARG TARGETPLATFORM
 ARG CI_COMMIT_SHA
@@ -23,6 +23,7 @@ RUN if [ -n "${CI_COMMIT_SHA}" ]; then \
             "https://s3.rustybever.be/vieter/commits/${CI_COMMIT_SHA}/vieter-$(echo "${TARGETPLATFORM}" | sed 's:/:-:g')" && \
             chmod +x vieter ; \
     else \
+        cd src && v install && cd .. && \
         LDFLAGS='-lz -lbz2 -llzma -lexpat -lzstd -llz4 -lsqlite3 -static' make prod && \
         mv pvieter vieter ; \
     fi

Makefile

@@ -1,16 +1,20 @@
 # =====CONFIG=====
 SRC_DIR := src
-SOURCES != find '$(SRC_DIR)' -iname '*.v'
+SRCS != find '$(SRC_DIR)' -iname '*.v'
 
 V_PATH ?= v
-V := $(V_PATH) -showcc -gc boehm
+V := $(V_PATH) -showcc -gc boehm -d use_openssl -skip-unused
 
 all: vieter
 
 
 # =====COMPILATION=====
+.PHONY: libvieter
+libvieter:
+	make -C '$(SRC_DIR)/libvieter' CFLAGS='-O3' 
+
 # Regular binary
-vieter: $(SOURCES)
+vieter: $(SOURCES) libvieter
 	$(V) -g -o vieter $(SRC_DIR)
 
 # Debug build using gcc
@@ -18,7 +22,7 @@ vieter: $(SOURCES)
 # multi-threaded and causes issues when running vieter inside gdb.
 .PHONY: debug
 debug: dvieter
-dvieter: $(SOURCES)
+dvieter: $(SOURCES) libvieter
 	$(V_PATH) -showcc -keepc -cg -o dvieter $(SRC_DIR)
 
 # Run the debug build inside gdb
@@ -29,12 +33,12 @@ gdb: dvieter
 # Optimised production build
 .PHONY: prod
 prod: pvieter
-pvieter: $(SOURCES)
+pvieter: $(SOURCES) libvieter
 	$(V) -o pvieter -prod $(SRC_DIR)
 
 # Only generate C code
 .PHONY: c
-c: $(SOURCES)
+c: $(SOURCES) libvieter
 	$(V) -o vieter.c $(SRC_DIR)
 
 
@@ -67,6 +71,7 @@ man: vieter
 
 
 # =====OTHER=====
+# Linting
 .PHONY: lint
 lint:
 	$(V) fmt -verify $(SRC_DIR)
@@ -74,34 +79,33 @@ lint:
 	$(V_PATH) missdoc -p $(SRC_DIR)
 	@ [ $$($(V_PATH) missdoc -p $(SRC_DIR) | wc -l) = 0 ]
 
-# Format the V codebase
+
+# Formatting
 .PHONY: fmt
 fmt:
 	$(V) fmt -w $(SRC_DIR)
 
+
+# Testing
 .PHONY: test
-test:
-	$(V) test $(SRC_DIR)
+test: libvieter
+	$(V) -g test $(SRC_DIR)
 
-# Build & patch the V compiler
-.PHONY: v
-v: v/v
-v/v:
-	git clone --single-branch https://git.rustybever.be/Chewing_Bever/v v
-	make -C v
 
+# Cleaning
 .PHONY: clean
 clean:
-	rm -rf 'data' 'vieter' 'dvieter' 'pvieter' 'vieter.c' 'dvieterctl' 'vieterctl' 'pkg' 'src/vieter' *.pkg.tar.zst 'suvieter' 'afvieter' '$(SRC_DIR)/_docs' 'docs/public'
+	rm -rf 'data' 'vieter' 'dvieter' 'pvieter' 'vieter.c' 'pkg' 'src/vieter' *.pkg.tar.zst 'suvieter' 'afvieter' '$(SRC_DIR)/_docs' 'docs/public'
+	make -C '$(SRC_DIR)/libvieter' clean
 
 
 # =====EXPERIMENTAL=====
 .PHONY: autofree
 autofree: afvieter
 afvieter: $(SOURCES)
-	$(V_PATH) -showcc -autofree -o afvieter $(SRC_DIR)
+	$(V) -showcc -autofree -o afvieter $(SRC_DIR)
 
 .PHONY: skip-unused
 skip-unused: suvieter
 suvieter: $(SOURCES)
-	$(V_PATH) -showcc -skip-unused -o suvieter $(SRC_DIR)
+	$(V) -skip-unused -o suvieter $(SRC_DIR)

PKGBUILD

@@ -3,18 +3,36 @@
 
 pkgbase='vieter'
 pkgname='vieter'
-pkgver='0.3.0_rc.1'
+pkgver='0.6.0'
 pkgrel=1
-pkgdesc="Vieter is a lightweight implementation of an Arch repository server."
+pkgdesc="Lightweight Arch repository server & package build system"
 depends=('glibc' 'openssl' 'libarchive' 'sqlite')
-makedepends=('git' 'vieter-v')
+makedepends=('git' 'vieter-vlang')
 arch=('x86_64' 'aarch64')
-url='https://git.rustybever.be/vieter/vieter'
+url='https://git.rustybever.be/vieter-v/vieter'
 license=('AGPL3')
-source=("$pkgname::git+https://git.rustybever.be/vieter/vieter#tag=${pkgver//_/-}")
-md5sums=('SKIP')
+source=(
+    "$pkgname::git+https://git.rustybever.be/vieter-v/vieter#tag=${pkgver//_/-}"
+    "libvieter::git+https://git.rustybever.be/vieter-v/libvieter"
+)
+md5sums=('SKIP' 'SKIP')
+
+prepare() {
+    cd "${pkgname}"
+
+    # Add the libvieter submodule
+    git submodule init
+    git config submodules.src/libvieter.url "${srcdir}/libvieter"
+    git -c protocol.file.allow=always submodule update
+
+    export VMODULES="${srcdir}/.vmodules"
+
+    cd src && v install
+}
 
 build() {
+    export VMODULES="$srcdir/.vmodules"
+
     cd "$pkgname"
 
     make prod

PKGBUILD.dev

@@ -5,25 +5,43 @@ pkgbase='vieter-git'
 pkgname='vieter-git'
 pkgver=0.2.0.r25.g20112b8
 pkgrel=1
-pkgdesc="Vieter is a lightweight implementation of an Arch repository server."
+pkgdesc="Lightweight Arch repository server & package build system (development version)"
 depends=('glibc' 'openssl' 'libarchive' 'sqlite')
-makedepends=('git' 'vieter-v')
+makedepends=('git' 'vieter-vlang')
 arch=('x86_64' 'aarch64')
-url='https://git.rustybever.be/vieter/vieter'
+url='https://git.rustybever.be/vieter-v/vieter'
 license=('AGPL3')
-source=("$pkgname::git+https://git.rustybever.be/vieter/vieter#branch=dev")
-md5sums=('SKIP')
+source=(
+    "${pkgname}::git+https://git.rustybever.be/vieter-v/vieter#branch=dev"
+    "libvieter::git+https://git.rustybever.be/vieter-v/libvieter"
+)
+md5sums=('SKIP' 'SKIP')
 provides=('vieter')
 conflicts=('vieter')
 
 pkgver() {
-    cd "$pkgname"
+    cd "${pkgname}"
 
     git describe --long --tags | sed 's/^v//;s/\([^-]*-g\)/r\1/;s/-/./g'
 }
 
+prepare() {
+    cd "${pkgname}"
+
+    # Add the libvieter submodule
+    git submodule init
+    git config submodules.src/libvieter.url "${srcdir}/libvieter"
+    git -c protocol.file.allow=always submodule update
+
+    export VMODULES="${srcdir}/.vmodules"
+
+    cd src && v install
+}
+
 build() {
-    cd "$pkgname"
+    export VMODULES="${srcdir}/.vmodules"
+
+    cd "${pkgname}"
 
     make prod
 
@@ -34,9 +52,9 @@ build() {
 }
 
 package() {
-    install -dm755 "$pkgdir/usr/bin"
-    install -Dm755 "$pkgname/pvieter" "$pkgdir/usr/bin/vieter"
+    install -dm755 "${pkgdir}/usr/bin"
+    install -Dm755 "${pkgname}/pvieter" "${pkgdir}/usr/bin/vieter"
 
-    install -dm755 "$pkgdir/usr/share/man/man1"
-    install -Dm644 "$pkgname/man"/*.1 "$pkgdir/usr/share/man/man1"
+    install -dm755 "${pkgdir}/usr/share/man/man1"
+    install -Dm644 "${pkgname}/man"/*.1 "${pkgdir}/usr/share/man/man1"
 }

README.md

@@ -1,11 +1,12 @@
 # Vieter
 
-## Documentation
-
 I host documentation for Vieter over at https://rustybever.be/docs/vieter/. API
 documentation for the current codebase can be found at
 https://rustybever.be/api-docs/vieter/.
 
+For more information, questions or just a chat, there's
+[#vieter:rustybever.be](https://matrix.to/#/#vieter:rustybever.be) on Matrix!
+
 ## Overview
 
 Vieter is a restart of the Pieter project. The goal is to create a simple,
@@ -20,7 +21,8 @@ quicker.
 I chose [V](https://vlang.io/) as I've been very intrigued by this language for
 a while now. I wanted a fast language that I could code while relaxing, without
 having to exert too much mental effort & V seemed like the right choice for
-that.
+that. Sadly, this didn't quite turn out the way I expected, but I'm sticking
+with it anyways ;p
 
 ## Features
 
@@ -36,22 +38,19 @@ that.
 
 Besides a V installer, Vieter also requires the following libraries to work:
 
-* gc
 * libarchive
 * openssl
 * sqlite3
 
+Vieter also depends on some external V modules which you can install using `cd
+src && v install`. Make sure to keep these dependencies up to date using `v
+update`.
+
 ### Compiler
 
-Vieter compiles with the standard Vlang compiler. However, I do maintain a
-[mirror](https://git.rustybever.be/vieter/v). This is to ensure my CI does not
-break without reason, as I control when & how frequently the mirror is updated
-to reflect the official repository.
-
-If you encounter issues using the latest V compiler, try using my mirror
-instead. `make v` will clone the repository & build the mirror. Afterwards,
-prepending any make command with `V_PATH=v/v` tells make to use the locally
-compiled mirror instead.
+V is developed using a specific compiler commit that is usually updated
+whenever a new version is released. Information on this can be found in the
+[tools](https://git.rustybever.be/vieter-v/tools) repository.
 
 ## Contributing
 

docs/api/source/includes/_jobs.md

@@ -0,0 +1,78 @@
+# Jobs
+
+<aside class="notice">
+
+All routes in this section require authentication.
+
+</aside>
+
+## Manually schedule a job
+
+```shell
+curl \
+  -H 'X-Api-Key: secret' \
+  https://example.com/api/v1/jobs/queue?target=10&force&arch=x86_64
+```
+
+Manually schedule a job on the server.
+
+### HTTP Request
+
+`POST /api/v1/jobs/queue`
+
+### Query Parameters
+
+Parameter | Description
+--------- | -----------
+target | Id of target to schedule build for
+arch | Architecture to build on
+force | Whether it's a forced build (true if present)
+
+## Poll for new jobs
+
+<aside class="warning">
+
+This endpoint is used by the agents and should not be used manually. It's just
+here for completeness. Requests to this endpoint modify the build queue,
+meaning manual requests can cause builds to be skipped.
+
+</aside>
+
+```shell
+curl \
+  -H 'X-Api-Key: secret' \
+  https://example.com/api/v1/jobs/poll?arch=x86_64&max=2
+```
+
+> JSON output format
+
+```json
+{
+  "message": "",
+  "data": [
+    {
+      "target_id": 1,
+      "kind": "git",
+      "url": "https://aur.archlinux.org/discord-ptb.git",
+      "branch": "master",
+      "path": "",
+      "repo": "bur",
+      "base_image": "archlinux:base-devel",
+      "force": true
+    }
+  ]
+}
+```
+
+Poll the server for new builds.
+
+### HTTP Request
+
+`GET /api/v1/jobs/poll`
+
+### Query Parameters
+
+Parameter | Description
+--------- | -----------
+arch | For which architecture to receive jobs
+max | How many jobs to receive at most

docs/api/source/includes/_logs.md

@@ -13,7 +13,7 @@ Endpoints for interacting with stored build logs.
 ```shell
 curl \
   -H 'X-Api-Key: secret' \
-  https://example.com/api/logs?offset=10&limit=20
+  https://example.com/api/v1/logs?offset=10&limit=20
 ```
 
 > JSON output format
@@ -24,7 +24,7 @@ curl \
   "data": [
     {
       "id": 1,
-      "repo_id": 3,
+      "target_id": 3,
       "start_time": 1652008554,
       "end_time": 1652008559,
       "arch": "x86_64",
@@ -38,7 +38,7 @@ Retrieve a list of build logs.
 
 ### HTTP Request
 
-`GET /api/logs`
+`GET /api/v1/logs`
 
 ### Query Parameters
 
@@ -46,7 +46,7 @@ Parameter | Description
 --------- | -----------
 limit | Maximum amount of results to return.
 offset | Offset of results.
-repo | Only return builds published to this repository.
+target | Only return builds for this target id.
 before | Only return logs started before this time (UTC epoch)
 after | Only return logs started after this time (UTC epoch)
 arch | Only return logs built on this architecture
@@ -58,7 +58,7 @@ exit_codes | Comma-separated list of exit codes to limit result to; using `!` as
 ```shell
 curl \
   -H 'X-Api-Key: secret' \
-  https://example.com/api/logs/15
+  https://example.com/api/v1/logs/1
 ```
 
 > JSON output format
@@ -68,7 +68,7 @@ curl \
   "message": "",
   "data": {
     "id": 1,
-    "repo_id": 3,
+    "target_id": 3,
     "start_time": 1652008554,
     "end_time": 1652008559,
     "arch": "x86_64",
@@ -81,7 +81,7 @@ Retrieve info about a specific build log.
 
 ### HTTP Request
 
-`GET /api/logs/:id`
+`GET /api/v1/logs/:id`
 
 ### URL Parameters
 
@@ -94,7 +94,7 @@ id | ID of requested log
 ```shell
 curl \
   -H 'X-Api-Key: secret' \
-  https://example.com/api/logs/15/content
+  https://example.com/api/v1/logs/15/content
 ```
 
 Retrieve the contents of a build log. The response is the build log in
@@ -102,7 +102,7 @@ plaintext.
 
 ### HTTP Request
 
-`GET /api/logs/:id/content`
+`GET /api/v1/logs/:id/content`
 
 ### URL Parameters
 
@@ -112,10 +112,21 @@ id | ID of requested log
 
 ## Publish build log
 
+> JSON output format
+
+```json
+{
+  "message": "",
+  "data": {
+    "id": 15
+  }
+}
+```
+
 <aside class="warning">
 
-You should probably not use this endpoint, as it's used by the build system to
-publish its logs.
+This endpoint is used by the agents and should not be used manually unless you
+know what you're doing. It's just here for completeness.
 
 </aside>
 
@@ -123,18 +134,39 @@ Publish a new build log to the server.
 
 ### HTTP Request
 
-`POST /api/logs`
+`POST /api/v1/logs`
 
 ### Query parameters
 
 Parameter | Description
 --------- | -----------
-id | ID of requested log
 startTime | Start time of the build (UTC epoch)
 endTime | End time of the build (UTC epoch)
 arch | Architecture on which the build was done
 exitCode | Exit code of the build container
+target | id of target this build is for
 
 ### Request body
 
 Plaintext contents of the build log.
+
+## Remove a build log
+
+```shell
+curl \
+  -XDELETE \
+  -H 'X-Api-Key: secret' \
+  https://example.com/api/v1/logs/1
+```
+
+Remove a build log from the server.
+
+### HTTP Request
+
+`DELETE /api/v1/logs/:id`
+
+### URL Parameters
+
+Parameter | Description
+--------- | -----------
+id | id of log to remove

docs/api/source/includes/_repository.md

@@ -93,3 +93,87 @@ other already present arch-repos.
 Parameter | Description
 --------- | -----------
 repo | Repository to publish package to
+
+## Remove package from arch-repo
+
+<aside class="notice">
+
+This endpoint requests authentication.
+
+</aside>
+
+```shell
+curl \
+  -H 'X-Api-Key: secret' \
+  -XDELETE \
+  https://example.com/vieter/x86_64/mike
+```
+
+This endpoint allows you to remove a package from a given arch-repo.
+
+### HTTP Request
+
+`DELETE /:repo/:arch/:pkg`
+
+### URL Parameters
+
+Parameter | Description
+--------- | -----------
+repo | Repository to delete package from
+arch | Specific arch-repo to remove package from
+pkg | Name of package to remove (without any version information)
+
+## Remove arch-repo
+
+<aside class="notice">
+
+This endpoint requests authentication.
+
+</aside>
+
+```shell
+curl \
+  -H 'X-Api-Key: secret' \
+  -XDELETE \
+  https://example.com/vieter/x86_64
+```
+
+This endpoint allows removing an entire arch-repo.
+
+### HTTP Request
+
+`DELETE /:repo/:arch`
+
+### URL Parameters
+
+Parameter | Description
+--------- | -----------
+repo | Repository to delete arch-repo from
+arch | Specific architecture to remove
+
+## Remove repo
+
+<aside class="notice">
+
+This endpoint requests authentication.
+
+</aside>
+
+```shell
+curl \
+  -H 'X-Api-Key: secret' \
+  -XDELETE \
+  https://example.com/vieter
+```
+
+This endpoint allows removing an entire repo.
+
+### HTTP Request
+
+`DELETE /:repo`
+
+### URL Parameters
+
+Parameter | Description
+--------- | -----------
+repo | Repository to delete

docs/api/source/includes/_targets.md

@@ -1,4 +1,4 @@
-# Git Repositories
+# Targets
 
 <aside class="notice">
 
@@ -6,15 +6,14 @@ All routes in this section require authentication.
 
 </aside>
 
-Endpoints for interacting with the list of Git repositories stored on the
-server.
+Endpoints for interacting with the list of targets stored on the server.
 
-## List repos
+## List targets
 
 ```shell
 curl \
   -H 'X-Api-Key: secret' \
-  https://example.com/api/repos?offset=10&limit=20
+  https://example.com/api/v1/targets?offset=10&limit=20
 ```
 
 > JSON output format
@@ -25,14 +24,16 @@ curl \
   "data": [
     {
       "id": 1,
+      "kind": "git",
       "url": "https://aur.archlinux.org/discord-ptb.git",
       "branch": "master",
+      "path" : "",
       "repo": "bur",
       "schedule": "",
       "arch": [
         {
           "id": 1,
-          "repo_id": 1,
+          "target_id": 1,
           "value": "x86_64"
         }
       ]
@@ -41,11 +42,11 @@ curl \
 }
 ```
 
-Retrieve a list of Git repositories.
+Retrieve a list of targets.
 
 ### HTTP Request
 
-`GET /api/repos`
+`GET /api/v1/targets`
 
 ### Query Parameters
 
@@ -53,14 +54,16 @@ Parameter | Description
 --------- | -----------
 limit | Maximum amount of results to return.
 offset | Offset of results.
-repo | Limit results to repositories that publish to the given repo.
+repo | Limit results to targets that publish to the given repo.
+query | Only return targets that have this substring in their URL, path or branch.
+arch | Only return targets that publish to this arch.
 
-## Get a repo
+## Get specific target
 
 ```shell
 curl \
   -H 'X-Api-Key: secret' \
-  https://example.com/api/repos/15
+  https://example.com/api/v1/targets/1
 ```
 
 > JSON output format
@@ -70,14 +73,16 @@ curl \
   "message": "",
   "data": {
     "id": 1,
+    "kind": "git",
     "url": "https://aur.archlinux.org/discord-ptb.git",
     "branch": "master",
+    "path": "",
     "repo": "bur",
-    "schedule": "0 3",
+    "schedule": "0 2",
     "arch": [
       {
         "id": 1,
-        "repo_id": 1,
+        "target_id": 1,
         "value": "x86_64"
       }
     ]
@@ -85,70 +90,92 @@ curl \
 }
 ```
 
-Get info about a specific Git repository.
+Get info about a specific target.
 
 ### HTTP Request
 
-`GET /api/repos/:id`
+`GET /api/v1/targets/:id`
 
 ### URL Parameters
 
 Parameter | Description
 --------- | -----------
-id | ID of requested repo
+id | id of requested target
 
-## Create a new repo
+## Create a new target
 
-Create a new Git repository with the given data.
+> JSON output format
+
+```json
+{
+  "message": "",
+  "data": {
+    "id": 15
+  }
+}
+```
+
+Create a new target with the given data.
 
 ### HTTP Request
 
-`POST /api/repos`
+`POST /api/v1/targets`
 
 ### Query Parameters
 
 Parameter | Description
 --------- | -----------
+kind | Kind of target to add; one of 'git', 'url'.
 url | URL of the Git repository.
 branch | Branch of the Git repository.
+path | Subdirectory inside Git repository to use.
 repo | Vieter repository to publish built packages to.
 schedule | Cron build schedule (syntax explained [here](https://rustybever.be/docs/vieter/usage/builds/schedule/))
 arch | Comma-separated list of architectures to build package on.
 
-## Modify a repo
+## Modify a target
 
-Modify the data of an existing Git repository.
+Modify the data of an existing target.
 
 ### HTTP Request
 
-`PATCH /api/repos/:id`
+`PATCH /api/v1/targets/:id`
 
 ### URL Parameters
 
 Parameter | Description
 --------- | -----------
-id | ID of requested repo
+id | id of target to modify
 
 ### Query Parameters
 
 Parameter | Description
 --------- | -----------
+kind | Kind of target; one of 'git', 'url'.
 url | URL of the Git repository.
 branch | Branch of the Git repository.
+path | Subdirectory inside Git repository to use.
 repo | Vieter repository to publish built packages to.
 schedule | Cron build schedule
 arch | Comma-separated list of architectures to build package on.
 
-## Remove a repo
+## Remove a target
 
-Remove a Git repository from the server.
+```shell
+curl \
+  -XDELETE \
+  -H 'X-Api-Key: secret' \
+  https://example.com/api/v1/targets/1
+```
+
+Remove a target from the server.
 
 ### HTTP Request
 
-`DELETE /api/repos/:id`
+`DELETE /api/v1/targets/:id`
 
 ### URL Parameters
 
 Parameter | Description
 --------- | -----------
-id | ID of repo to remove
+id | id of target to remove

docs/api/source/index.html.md

@@ -9,8 +9,9 @@ toc_footers:
 
 includes:
   - repository
-  - git
+  - targets
   - logs
+  - jobs
 
 search: true
 

docs/config.toml

@@ -38,7 +38,7 @@ enableGitInfo = true
   weight = 20
 [[menu.after]]
   name = "Vieter"
-  url = "https://git.rustybever.be/vieter/vieter"
+  url = "https://git.rustybever.be/vieter-v/vieter"
   weight = 30
 [[menu.after]]
   name = "Hugo Theme"
@@ -70,7 +70,7 @@ enableGitInfo = true
 
   # Set source repository location.
   # Used for 'Last Modified' and 'Edit this page' links.
-  BookRepo = 'https://git.rustybever.be/vieter/vieter'
+  BookRepo = 'https://git.rustybever.be/vieter-v/vieter'
 
   # (Optional, default 'commit') Specifies commit portion of the link to the page's last modified
   # commit hash for 'doc' page type.

docs/content/configuration.md

@@ -17,7 +17,7 @@ If a variable is both present in the config file & as an environment variable,
 the value in the environment variable is used.
 
 {{< hint info >}}
-**Note**  
+**Note**
 All environment variables can also be provided from a file by appending them
 with `_FILE`. This for example allows you to provide the API key from a Docker
 secrets file.
@@ -26,17 +26,17 @@ secrets file.
 ## Commands
 
 The first argument passed to Vieter determines which command you wish to use.
-Each of these can contain subcommands (e.g. `vieter repos list`), but all
+Each of these can contain subcommands (e.g. `vieter targets list`), but all
 subcommands will use the same configuration. Below you can find the
 configuration variable required for each command.
 
 ### `vieter server`
 
+* `port`: HTTP port to run on
+    * Default: `8000`
 * `log_level`: log verbosity level. Value should be one of `FATAL`, `ERROR`,
   `WARN`, `INFO` or `DEBUG`.
     * Default: `WARN`
-* `log_file`: log file to write logs to.
-    * Default: `vieter.log` (in the current directory)
 * `pkg_dir`:  where Vieter should store the actual package archives.
 * `data_dir`: where Vieter stores the repositories, log file & database.
 * `api_key`: the API key to use when authenticating requests.
@@ -44,8 +44,26 @@ configuration variable required for each command.
     * Packages with architecture `any` are always added to this architecture.
       This prevents the server from being confused when an `any` package is
       published as the very first package for a repository.
-    * Git repositories added without an `arch` value use this value instead.
-
+    * Targets added without an `arch` value use this value instead.
+* `global_schedule`: build schedule for any target that does not have a
+  schedule defined. For information about this syntax, see
+  [here](/usage/builds/schedule).
+    * Default: `0 3` (3AM every night)
+* `base_image`: Docker image to use when building a package. Any Pacman-based
+  distro image should work, as long as `/etc/pacman.conf` is used &
+  `base-devel` exists in the repositories. Make sure that the image supports
+  the architecture of your cron daemon.
+    * Default: `archlinux:base-devel` (only works on `x86_64`). If you require
+      `aarch64` support, consider using
+      [`menci/archlinuxarm:base-devel`](https://hub.docker.com/r/menci/archlinuxarm)
+      ([GitHub](https://github.com/Menci/docker-archlinuxarm)). This is the
+      image used for the Vieter CI builds.
+* `max_log_age`: maximum age of logs (in days). Logs older than this will get
+  cleaned by the log removal daemon. If set to zero, no logs are ever removed.
+  The age of logs is determined by the time the build was started.
+    * Default: `0`
+* `log_removal_schedule`: cron schedule defining when to clean old logs.
+    * Default: `0 0` (every day at midnight)
 
 ### `vieter cron`
 
@@ -88,11 +106,33 @@ configuration variable required for each command.
 * `api_key`: the API key to use when authenticating requests.
 * `address`: Base URL of your Vieter instance, e.g. https://example.com
 
-### `vieter repos`
+### `vieter targets`
 
 * `api_key`: the API key to use when authenticating requests.
 * `address`: Base URL of your Vieter instance, e.g. https://example.com
-* `base_image`: image to use when building a package using `vieter repos
+* `base_image`: image to use when building a package using `vieter targets
   build`.
     * Default: `archlinux:base-devel`
 
+### `vieter agent`
+
+* `log_level`: log verbosity level. Value should be one of `FATAL`, `ERROR`,
+  `WARN`, `INFO` or `DEBUG`.
+    * Default: `WARN`
+* `address`: *public* URL of the Vieter repository server to build for. From
+  this server jobs are retrieved. All built packages are published to this
+  server.
+* `api_key`: API key of the above server.
+* `data_dir`: directory to store log file in.
+* `max_concurrent_builds`: how many builds to run at the same time.
+    * Default: `1`
+* `polling_frequency`: how often (in seconds) to poll the server for new
+  builds. Note that the agent might poll more frequently when it's actively
+  processing builds.
+* `image_rebuild_frequency`: Vieter periodically builds images that are then
+  used as a basis for running build containers. This is to prevent each build
+  from downloading an entire repository worth of dependencies. This setting
+  defines how frequently (in minutes) to rebuild these images.
+    * Default: `1440` (every 24 hours)
+* `arch`: architecture for which this agent should pull down builds (e.g.
+  `x86_64`)

docs/content/installation.md

@@ -21,17 +21,17 @@ branch. This branch will be the most up to date, but does not give any
 guarantees about stability, so beware!
 
 Thanks to the single-binary design of Vieter, this image can be used both for
-the repository server & the cron daemon.
+the repository server, the cron daemon and the agent.
 
-Below is an example compose file to set up both the repository server & the
-cron daemon:
+Below is a minimal compose file to set up both the repository server & a build
+agent:
 
 ```yaml
 version: '3'
 
 services:
   server:
-    image: 'chewingbever/vieter:dev'
+    image: 'chewingbever/vieter:0.5.0-rc.1'
     restart: 'always'
 
     environment:
@@ -41,18 +41,19 @@ services:
       - 'data:/data'
 
   cron:
-    image: 'chewingbever/vieter:dev'
+    image: 'chewingbever/vieter:0.5.0-rc.1'
     restart: 'always'
+    # Required to connect to the Docker daemon
     user: root
-    command: 'vieter cron'
+    command: 'vieter agent'
 
     environment:
       - 'VIETER_API_KEY=secret'
       # MUST be public URL of Vieter repository
       - 'VIETER_ADDRESS=https://example.com'
-      - 'VIETER_DEFAULT_ARCH=x86_64'
+      # Architecture for which the agent builds
+      - 'VIETER_ARCH=x86_64'
       - 'VIETER_MAX_CONCURRENT_BUILDS=2'
-      - 'VIETER_GLOBAL_SCHEDULE=0 3'
     volumes:
       - '/var/run/docker.sock:/var/run/docker.sock'
 
@@ -63,20 +64,23 @@ volumes:
 If you do not require the build system, the repository server can be used
 independently as well.
 
+Of course, Vieter allows a lot more configuration than this. This compose file
+is meant as a starting point for setting up your installation.
+
 {{< hint info >}}
 **Note**  
-Builds are executed on the cron daemon's system using the host's Docker daemon.
-A cron daemon on a specific architecture will only build packages for that
-specific architecture. Therefore, if you wish to build packages for both
-`x86_64` & `aarch64`, you'll have to deploy two cron daemons, one on each
-architecture. Afterwards, any Git repositories enabled for those two
-architectures will build on both.
+Builds are executed on the agent's system using the host's Docker daemon. An
+agent for a specific `arch` will only build packages for that specific
+architecture. Therefore, if you wish to build packages for both `x86_64` &
+`aarch64`, you'll have to deploy two agents, one on each architecture.
+Afterwards, any Git repositories enabled for those two architectures will build
+on both.
 {{< /hint >}}
 
 ## Binary
 
 On the
-[releases](https://git.rustybever.be/vieter/vieter/releases)
+[releases](https://git.rustybever.be/vieter-v/vieter/releases)
 page, you can find statically compiled binaries for all
 released versions. This is the same binary as used inside
 the Docker images.
@@ -96,7 +100,15 @@ SigLevel = Optional
 Afterwards, you can update your system & install the `vieter` package for the
 latest official release or `vieter-git` for the latest development release.
 
+### AUR
+
+If you prefer building the packages locally (or on your own Vieter instance),
+there's the [`vieter`](https://aur.archlinux.org/packages/vieter) &
+[`vieter-git`](https://aur.archlinux.org/packages/vieter-git) packages on the
+AUR. These packages build using the `vlang` compiler package, so I can't
+guarantee that a compiler update won't temporarily break them.
+
 ## Building from source
 
-The project [README](https://git.rustybever.be/vieter/vieter#building) contains
-instructions for building Vieter from source.
+The project [README](https://git.rustybever.be/vieter-v/vieter#building)
+contains instructions for building Vieter from source.

docs/content/other/_index.md

@@ -1,3 +0,0 @@
----
-weight: 100
----

docs/content/other/builds-in-depth.md

@@ -1,81 +0,0 @@
-# Builds In-depth
-
-For those interested, this page describes how the build system works
-internally.
-
-## Builder image
-
-Every cron daemon perodically creates a builder image that is then used as a
-base for all builds. This is done to prevent build containers having to pull
-down a bunch of updates when they update their system.
-
-The build container is created by running the following commands inside a
-container started from the image defined in `base_image`:
-
-```sh
-# Update repos & install required packages
-pacman -Syu --needed --noconfirm base-devel git
-# Add a non-root user to run makepkg
-groupadd -g 1000 builder
-useradd -mg builder builder
-# Make sure they can use sudo without a password
-echo 'builder ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers
-# Create the directory for the builds & make it writeable for the
-# build user
-mkdir /build
-chown -R builder:builder /build
-```
-
-This script updates the packages to their latest versions & creates a non-root
-user to use when running `makepkg`.
-
-This script is base64-encoded & passed to the container as an environment
-variable. The container's entrypoint is set to `/bin/sh -c` & its command
-argument to `echo $BUILD_SCRIPT | base64 -d | /bin/sh -e`, with the
-`BUILD_SCRIPT` environment variable containing the base64-encoded script.
-
-Once the container exits, a new Docker image is created from it. This image is
-then used as the base for any builds.
-
-## Running builds
-
-Each build has its own Docker container, using the builder image as its base.
-The same base64-based technique as above is used, just with a different script.
-To make the build logs more clear, each command is appended by an echo command
-printing the next command to stdout.
-
-Given the Git repository URL is `https://examplerepo.com` with branch `main`,
-the URL of the Vieter server is `https://example.com` and `vieter` is the
-repository we wish to publish to, we get the following script:
-
-```sh
-echo -e '+ echo -e '\''[vieter]\\nServer = https://example.com/$repo/$arch\\nSigLevel = Optional'\'' >> /etc/pacman.conf'
-echo -e '[vieter]\nServer = https://example.com/$repo/$arch\nSigLevel = Optional' >> /etc/pacman.conf
-echo -e '+ pacman -Syu --needed --noconfirm'
-pacman -Syu --needed --noconfirm
-echo -e '+ su builder'
-su builder
-echo -e '+ git clone --single-branch --depth 1 --branch main https://examplerepo.com repo'
-git clone --single-branch --depth 1 --branch main https://examplerepo.com repo
-echo -e '+ cd repo'
-cd repo
-echo -e '+ makepkg --nobuild --syncdeps --needed --noconfirm'
-makepkg --nobuild --syncdeps --needed --noconfirm
-echo -e '+ source PKGBUILD'
-source PKGBUILD
-echo -e '+ curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0'
-curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0
-echo -e '+ [ "$(id -u)" == 0 ] && exit 0'
-[ "$(id -u)" == 0 ] && exit 0
-echo -e '+ MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done'
-MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done
-```
-
-This script:
-
-1. Adds the target repository as a repository in the build container
-2. Updates mirrors & packages
-3. Clones the Git repository
-4. Runs `makepkg` without building to calculate `pkgver`
-5. Checks whether the package version is already present on the server
-6. If not, run `makepkg` & publish any generated package archives to the server

docs/content/usage/builds/_index.md

@@ -16,28 +16,28 @@ info to the system. The Vieter repository server exposes an HTTP API for this
 info). For ease of use, the Vieter binary contains a CLI interface for
 interacting with this API (see [Configuration](/configuration) for
 configuration details). The [man
-pages](https://rustybever.be/man/vieter/vieter-repos.1.html) describe this in
+pages](https://rustybever.be/man/vieter/vieter-targets.1.html) describe this in
 greater detail, but the basic usage is as follows:
 
 ```
-vieter repos add some-url some-branch some-repository
+vieter targets add some-url some-repository
 ```
 
 Here, `some-url` is the URL of the Git repository containing the PKGBUILD. This
 URL is passed to `git clone`, meaning the repository should be public. Vieter
 expects the same format as an AUR Git repository, so you can directly use AUR
-URLs here.
+URLs here. Alternatively, you can also provide the URL to a PKGBUILD file
+instead. See
+[vieter-targets-add(1)](https://rustybever.be/man/vieter/vieter-targets-add.1.html)
+for more information.
 
-`some-branch` is the branch of the Git repository the build should check out.
-If you're using an AUR package, this should be `master`.
-
-Finally, `some-repo` is the repository to which the built package archives
-should be published.
+`some-repo` is the repository to which the built package archives should be
+published.
 
 The above command intentionally leaves out a few parameters to make the CLI
 more useable. For information on how to modify all parameters using the CLI,
 see
-[vieter-repos-edit(1)](https://rustybever.be/man/vieter/vieter-repos-edit.1.html).
+[vieter-targets(1)](https://rustybever.be/man/vieter/vieter-targets.1.html).
 
 ## Reading logs
 

docs/content/usage/builds/cleanup.md

@@ -0,0 +1,23 @@
+---
+weight: 20
+---
+
+# Cleanup
+
+Vieter stores the logs of every single package build. While this is great for
+debugging why builds fail, it also causes an active or long-running Vieter
+instance to accumulate thousands of logs.
+
+To combat this, a log removal daemon can be enabled that periodically removes
+old build logs. By starting your server with the `max_log_age` variable (see
+[Configuration](/configuration#vieter-server)), a daemon will get enabled that
+periodically removes logs older than this setting. By default, this will happen
+every day at midnight, but this behavior can be changed using the
+`log_removal_schedule` variable.
+
+{{< hint info >}}
+**Note**  
+The daemon will always run a removal of logs on startup. Therefore, it's
+possible the daemon will be *very* active when first enabling this setting.
+After the initial surge of logs to remove, it'll calm down again.
+{{< /hint >}}

docs/content/usage/builds/schedule.md

@@ -1,3 +1,7 @@
+---
+weight: 10
+---
+
 # Cron schedule syntax
 
 The Vieter cron daemon uses a subset of the cron expression syntax to schedule
@@ -37,6 +41,6 @@ Each section can consist of as many of these parts as necessary.
 ## CLI tool
 
 The Vieter binary contains a command that shows you the next matching times for
-a given expression. This can be useful to understand the syntax. For more
+a given expression. This can be useful for understanding the syntax. For more
 information, see
 [vieter-schedule(1)](https://rustybever.be/man/vieter/vieter-schedule.1.html).

src/agent/agent.v

@@ -0,0 +1,27 @@
+module agent
+
+import log
+import os
+import util
+
+const log_file_name = 'vieter.agent.log'
+
+// agent starts an agent service
+pub fn agent(conf Config) ! {
+	log_level := log.level_from_tag(conf.log_level) or {
+		return error('Invalid log level. The allowed values are FATAL, ERROR, WARN, INFO & DEBUG.')
+	}
+
+	mut logger := log.Log{
+		level: log_level
+	}
+
+	os.mkdir_all(conf.data_dir) or { util.exit_with_message(1, 'Failed to create data directory.') }
+
+	log_file := os.join_path_single(conf.data_dir, agent.log_file_name)
+	logger.set_full_logpath(log_file)
+	logger.log_to_console_too()
+
+	mut d := agent_init(logger, conf)
+	d.run()
+}

src/agent/cli.v

@@ -0,0 +1,31 @@
+module agent
+
+import cli
+import conf as vconf
+
+struct Config {
+pub:
+	log_level string = 'WARN'
+	// Architecture that the agent represents
+	arch                    string
+	api_key                 string
+	address                 string
+	data_dir                string
+	max_concurrent_builds   int = 1
+	polling_frequency       int = 30
+	image_rebuild_frequency int = 1440
+}
+
+// cmd returns the cli module that handles the cron daemon.
+pub fn cmd() cli.Command {
+	return cli.Command{
+		name: 'agent'
+		description: 'Start an agent daemon.'
+		execute: fn (cmd cli.Command) ! {
+			config_file := cmd.flags.get_string('config-file')!
+			conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+			agent(conf_)!
+		}
+	}
+}

src/agent/daemon.v

@@ -0,0 +1,197 @@
+module agent
+
+import log
+import sync.stdatomic
+import build
+import models { BuildConfig }
+import client
+import time
+import os
+
+const (
+	build_empty   = 0
+	build_running = 1
+	build_done    = 2
+)
+
+struct AgentDaemon {
+	logger shared log.Log
+	conf   Config
+	client client.Client
+mut:
+	images ImageManager
+	// Atomic variables used to detect when a build has finished; length is
+	// conf.max_concurrent_builds. This approach is used as the difference
+	// between a recently finished build and an empty build slot is important
+	// for knowing whether the agent is currently "active".
+	atomics []u64
+	// Channel used to send builds to worker threads
+	build_channel chan BuildConfig
+}
+
+// agent_init initializes a new agent
+fn agent_init(logger log.Log, conf Config) AgentDaemon {
+	mut d := AgentDaemon{
+		logger: logger
+		client: client.new(conf.address, conf.api_key)
+		conf: conf
+		images: new_image_manager(conf.image_rebuild_frequency * 60)
+		atomics: []u64{len: conf.max_concurrent_builds}
+		build_channel: chan BuildConfig{cap: conf.max_concurrent_builds}
+	}
+
+	return d
+}
+
+// run starts the actual agent daemon. This function will run forever.
+pub fn (mut d AgentDaemon) run() {
+	// Spawn worker threads
+	for builder_index in 0 .. d.conf.max_concurrent_builds {
+		spawn d.builder_thread(d.build_channel, builder_index)
+	}
+
+	// This is just so that the very first time the loop is ran, the jobs are
+	// always polled
+	mut last_poll_time := time.now().add_seconds(-d.conf.polling_frequency)
+	mut sleep_time := 0 * time.second
+	mut finished, mut empty, mut running := 0, 0, 0
+
+	for {
+		if sleep_time > 0 {
+			d.ldebug('Sleeping for ${sleep_time}')
+			time.sleep(sleep_time)
+		}
+
+		finished, empty = d.update_atomics()
+		running = d.conf.max_concurrent_builds - finished - empty
+
+		// No new finished builds and no free slots, so there's nothing to be
+		// done
+		if finished + empty == 0 {
+			sleep_time = 1 * time.second
+			continue
+		}
+
+		// Builds have finished, so old builder images might have freed up.
+		// TODO this might query the docker daemon too frequently.
+		if finished > 0 {
+			d.images.clean_old_images()
+		}
+
+		// The agent will always poll for new jobs after at most
+		// `polling_frequency` seconds. However, when jobs have finished, the
+		// agent will also poll for new jobs. This is because jobs are often
+		// clustered together (especially when mostly using the global cron
+		// schedule), so there's a much higher chance jobs are available.
+		if finished > 0 || time.now() >= last_poll_time.add_seconds(d.conf.polling_frequency) {
+			d.ldebug('Polling for new jobs')
+
+			new_configs := d.client.poll_jobs(d.conf.arch, finished + empty) or {
+				d.lerror('Failed to poll jobs: ${err.msg()}')
+
+				// TODO pick a better delay here
+				sleep_time = 5 * time.second
+				continue
+			}
+
+			d.ldebug('Received ${new_configs.len} jobs')
+
+			last_poll_time = time.now()
+
+			for config in new_configs {
+				// Make sure a recent build base image is available for
+				// building the config
+				if !d.images.up_to_date(config.base_image) {
+					d.linfo('Building builder image from base image ${config.base_image}')
+
+					// TODO handle this better than to just skip the config
+					d.images.refresh_image(config.base_image) or {
+						d.lerror(err.msg())
+						continue
+					}
+				}
+
+				// It's technically still possible that the build image is
+				// removed in the very short period between building the
+				// builder image and starting a build container with it. If
+				// this happens, fate really just didn't want you to do this
+				// build.
+
+				d.build_channel <- config
+				running++
+			}
+		}
+
+		// The agent is not doing anything, so we just wait until the next poll
+		// time
+		if running == 0 {
+			sleep_time = last_poll_time.add_seconds(d.conf.polling_frequency) - time.now()
+		} else {
+			sleep_time = 1 * time.second
+		}
+	}
+}
+
+// update_atomics checks for each build whether it's completed, and sets it to
+// empty again if so. The return value is a tuple `(finished, empty)` where
+// `finished` is how many builds were just finished and thus set to empty, and
+// `empty` is how many build slots were already empty. The amount of running
+// builds can then be calculated by substracting these two values from the
+// total allowed concurrent builds.
+fn (mut d AgentDaemon) update_atomics() (int, int) {
+	mut finished := 0
+	mut empty := 0
+
+	for i in 0 .. d.atomics.len {
+		if stdatomic.load_u64(&d.atomics[i]) == agent.build_done {
+			stdatomic.store_u64(&d.atomics[i], agent.build_empty)
+			finished++
+		} else if stdatomic.load_u64(&d.atomics[i]) == agent.build_empty {
+			empty++
+		}
+	}
+
+	return finished, empty
+}
+
+// run_build actually starts the build process for a given target.
+fn (mut d AgentDaemon) run_build(build_index int, config BuildConfig) {
+	d.linfo('started build: ${config}')
+
+	// 0 means success, 1 means failure
+	mut status := 0
+
+	new_config := BuildConfig{
+		...config
+		base_image: d.images.get(config.base_image)
+	}
+
+	res := build.build_config(d.client.address, d.client.api_key, new_config) or {
+		d.ldebug('build_config error: ${err.msg()}')
+		status = 1
+
+		build.BuildResult{}
+	}
+
+	if status == 0 {
+		d.linfo('Uploading build logs for ${config}')
+
+		// TODO use the arch value here
+		build_arch := os.uname().machine
+		d.client.add_build_log(config.target_id, res.start_time, res.end_time, build_arch,
+			res.exit_code, res.logs) or { d.lerror('Failed to upload logs for ${config}') }
+	} else {
+		d.lwarn('an error occurred during build: ${config}')
+	}
+
+	stdatomic.store_u64(&d.atomics[build_index], agent.build_done)
+}
+
+// builder_thread is a thread that constantly listens for builds to process
+fn (mut d AgentDaemon) builder_thread(ch chan BuildConfig, builder_index int) {
+	for {
+		build_config := <-ch or { break }
+
+		d.run_build(builder_index, build_config)
+	}
+}

src/agent/images.v

@@ -0,0 +1,119 @@
+module agent
+
+import time
+import docker
+import build
+
+// An ImageManager is a utility that creates builder images from given base
+// images, updating these builder images if they've become too old. This
+// structure can manage images from any number of base images, paving the way
+// for configurable base images per target/repository.
+struct ImageManager {
+	max_image_age int [required]
+mut:
+	// For each base image, one or more builder images can exist at the same
+	// time
+	images map[string][]string [required]
+	// For each base image, we track when its newest image was built
+	timestamps map[string]time.Time [required]
+}
+
+// new_image_manager initializes a new image manager.
+fn new_image_manager(max_image_age int) ImageManager {
+	return ImageManager{
+		max_image_age: max_image_age
+		images: map[string][]string{}
+		timestamps: map[string]time.Time{}
+	}
+}
+
+// get returns the name of the newest image for the given base image. Note that
+// this function should only be called *after* a first call to `refresh_image`.
+pub fn (m &ImageManager) get(base_image string) string {
+	return m.images[base_image].last()
+}
+
+// up_to_date returns true if the last known builder image exists and is up to
+// date. If this function returns true, the last builder image may be used to
+// perform a build.
+pub fn (mut m ImageManager) up_to_date(base_image string) bool {
+	if base_image !in m.timestamps
+		|| m.timestamps[base_image].add_seconds(m.max_image_age) <= time.now() {
+		return false
+	}
+
+	// It's possible the image has been removed by some external event, so we
+	// check whether it actually exists as well.
+	mut dd := docker.new_conn() or { return false }
+
+	defer {
+		dd.close() or {}
+	}
+
+	dd.image_inspect(m.images[base_image].last()) or {
+		// Image doesn't exist, so we stop tracking it
+		if err.code() == 404 {
+			m.images[base_image].delete_last()
+			m.timestamps.delete(base_image)
+		}
+
+		// If the inspect fails, it's either because the image doesn't exist or
+		// because of some other error. Either way, we can't know *for certain*
+		// that the image exists, so we return false.
+		return false
+	}
+
+	return true
+}
+
+// refresh_image builds a new builder image from the given base image. This
+// function should only be called if `up_to_date` returned false.
+fn (mut m ImageManager) refresh_image(base_image string) ! {
+	// TODO use better image tags for built images
+	new_image := build.create_build_image(base_image) or {
+		return error('Failed to build builder image from base image ${base_image}')
+	}
+
+	m.images[base_image] << new_image
+	m.timestamps[base_image] = time.now()
+}
+
+// clean_old_images removes all older builder images that are no longer in use.
+// The function will always leave at least one builder image, namely the newest
+// one.
+fn (mut m ImageManager) clean_old_images() {
+	mut dd := docker.new_conn() or { return }
+
+	defer {
+		dd.close() or {}
+	}
+
+	mut i := 0
+
+	for image in m.images.keys() {
+		i = 0
+
+		for i < m.images[image].len - 1 {
+			// For each builder image, we try to remove it by calling the Docker
+			// API. If the function returns an error or false, that means the image
+			// wasn't deleted. Therefore, we move the index over. If the function
+			// returns true, the array's length has decreased by one so we don't
+			// move the index.
+			dd.image_remove(m.images[image][i]) or {
+				// The image was removed by an external event
+				if err.code() == 404 {
+					m.images[image].delete(i)
+				}
+				// The image couldn't be removed, so we need to keep track of
+				// it
+				else {
+					i += 1
+				}
+
+				continue
+			}
+
+			m.images[image].delete(i)
+		}
+	}
+}

src/agent/log.v

@@ -0,0 +1,36 @@
+module agent
+
+// lfatal create a log message with the fatal level
+pub fn (mut d AgentDaemon) lfatal(msg string) {
+	lock d.logger {
+		d.logger.fatal(msg)
+	}
+}
+
+// lerror create a log message with the error level
+pub fn (mut d AgentDaemon) lerror(msg string) {
+	lock d.logger {
+		d.logger.error(msg)
+	}
+}
+
+// lwarn create a log message with the warn level
+pub fn (mut d AgentDaemon) lwarn(msg string) {
+	lock d.logger {
+		d.logger.warn(msg)
+	}
+}
+
+// linfo create a log message with the info level
+pub fn (mut d AgentDaemon) linfo(msg string) {
+	lock d.logger {
+		d.logger.info(msg)
+	}
+}
+
+// ldebug create a log message with the debug level
+pub fn (mut d AgentDaemon) ldebug(msg string) {
+	lock d.logger {
+		d.logger.debug(msg)
+	}
+}

src/archive.c.v

@@ -4,7 +4,7 @@
 
 #include "archive.h"
 
-struct C.archive {}
+pub struct C.archive {}
 
 // Create a new archive struct for reading
 fn C.archive_read_new() &C.archive
@@ -71,7 +71,7 @@ fn C.archive_filter_code(&C.archive, int) int
 
 #include "archive_entry.h"
 
-struct C.archive_entry {}
+pub struct C.archive_entry {}
 
 // Create a new archive_entry struct
 fn C.archive_entry_new() &C.archive_entry

src/build/build.v

@@ -6,11 +6,14 @@ import time
 import os
 import strings
 import util
-import models { GitRepo }
+import models { BuildConfig, Target }
 
 const (
 	container_build_dir = '/build'
 	build_image_repo    = 'vieter-build'
+	// Contents of PATH variable in build containers
+	path_dirs           = ['/sbin', '/bin', '/usr/sbin', '/usr/bin', '/usr/local/sbin',
+		'/usr/local/bin', '/usr/bin/site_perl', '/usr/bin/vendor_perl', '/usr/bin/core_perl']
 )
 
 // create_build_image creates a builder image given some base image which can
@@ -18,8 +21,8 @@ const (
 // system, install some necessary packages & creates a non-root user to run
 // makepkg with. The base image should be some Linux distribution that uses
 // Pacman as its package manager.
-pub fn create_build_image(base_image string) ?string {
-	mut dd := docker.new_conn()?
+pub fn create_build_image(base_image string) !string {
+	mut dd := docker.new_conn()!
 
 	defer {
 		dd.close() or {}
@@ -42,7 +45,7 @@ pub fn create_build_image(base_image string) ?string {
 
 	c := docker.NewContainer{
 		image: base_image
-		env: ['BUILD_SCRIPT=$cmds_str']
+		env: ['BUILD_SCRIPT=${cmds_str}']
 		entrypoint: ['/bin/sh', '-c']
 		cmd: ['echo \$BUILD_SCRIPT | base64 -d | /bin/sh -e']
 	}
@@ -54,15 +57,15 @@ pub fn create_build_image(base_image string) ?string {
 	image_tag := if image_parts.len > 1 { image_parts[1] } else { 'latest' }
 
 	// We pull the provided image
-	dd.pull_image(image_name, image_tag)?
+	dd.image_pull(image_name, image_tag)!
 
-	id := dd.create_container(c)?.id
-	// id := docker.create_container(c)?
-	dd.start_container(id)?
+	id := dd.container_create(c)!.id
+	// id := docker.create_container(c)!
+	dd.container_start(id)!
 
 	// This loop waits until the container has stopped, so we can remove it after
 	for {
-		data := dd.inspect_container(id)?
+		data := dd.container_inspect(id)!
 
 		if !data.state.running {
 			break
@@ -76,8 +79,8 @@ pub fn create_build_image(base_image string) ?string {
 	// TODO also add the base image's name into the image name to prevent
 	// conflicts.
 	tag := time.sys_mono_now().str()
-	image := dd.create_image_from_container(id, 'vieter-build', tag)?
-	dd.remove_container(id)?
+	image := dd.image_from_container(id, 'vieter-build', tag)!
+	dd.container_remove(id)!
 
 	return image.id
 }
@@ -90,51 +93,72 @@ pub:
 	logs       string
 }
 
-// build_repo builds, packages & publishes a given Arch package based on the
-// provided GitRepo. The base image ID should be of an image previously created
+// build_target builds the given target. Internally it calls `build_config`.
+pub fn build_target(address string, api_key string, base_image_id string, target &Target, force bool, timeout int) !BuildResult {
+	config := target.as_build_config(base_image_id, force, timeout)
+
+	return build_config(address, api_key, config)
+}
+
+// build_config builds, packages & publishes a given Arch package based on the
+// provided target. The base image ID should be of an image previously created
 // by create_build_image. It returns the logs of the container.
-pub fn build_repo(address string, api_key string, base_image_id string, repo &GitRepo) ?BuildResult {
-	mut dd := docker.new_conn()?
+pub fn build_config(address string, api_key string, config BuildConfig) !BuildResult {
+	mut dd := docker.new_conn()!
 
 	defer {
 		dd.close() or {}
 	}
 
 	build_arch := os.uname().machine
-	build_script := create_build_script(address, repo, build_arch)
+	build_script := create_build_script(address, config, build_arch)
 
 	// We convert the build script into a base64 string, which then gets passed
 	// to the container as an env var
 	base64_script := base64.encode_str(build_script)
 
 	c := docker.NewContainer{
-		image: '$base_image_id'
-		env: ['BUILD_SCRIPT=$base64_script', 'API_KEY=$api_key']
+		image: '${config.base_image}'
+		env: [
+			'BUILD_SCRIPT=${base64_script}',
+			'API_KEY=${api_key}',
+			// `archlinux:base-devel` does not correctly set the path variable,
+			// causing certain builds to fail. This fixes it.
+			'PATH=${build.path_dirs.join(':')}',
+		]
 		entrypoint: ['/bin/sh', '-c']
 		cmd: ['echo \$BUILD_SCRIPT | base64 -d | /bin/bash -e']
 		work_dir: '/build'
 		user: '0:0'
 	}
 
-	id := dd.create_container(c)?.id
-	dd.start_container(id)?
+	id := dd.container_create(c)!.id
+	dd.container_start(id)!
 
-	mut data := dd.inspect_container(id)?
+	mut data := dd.container_inspect(id)!
+	start_time := time.now()
 
 	// This loop waits until the container has stopped, so we can remove it after
 	for data.state.running {
+		if time.now() - start_time > config.timeout * time.second {
+			dd.container_kill(id)!
+			dd.container_remove(id)!
+
+			return error('Build killed due to timeout (${config.timeout}s)')
+		}
+
 		time.sleep(1 * time.second)
 
-		data = dd.inspect_container(id)?
+		data = dd.container_inspect(id)!
 	}
 
-	mut logs_stream := dd.get_container_logs(id)?
+	mut logs_stream := dd.container_get_logs(id)!
 
 	// Read in the entire stream
 	mut logs_builder := strings.new_builder(10 * 1024)
-	util.reader_to_writer(mut logs_stream, mut logs_builder)?
+	util.reader_to_writer(mut logs_stream, mut logs_builder)!
 
-	dd.remove_container(id)?
+	dd.container_remove(id)!
 
 	return BuildResult{
 		start_time: data.state.start_time

src/build/queue.v

@@ -0,0 +1,219 @@
+module build
+
+import models { BuildConfig, Target }
+import cron
+import time
+import datatypes { MinHeap }
+import util
+
+struct BuildJob {
+pub mut:
+	// Time at which this build job was created/queued
+	created time.Time
+	// Next timestamp from which point this job is allowed to be executed
+	timestamp time.Time
+	// Required for calculating next timestamp after having pop'ed a job
+	ce &cron.Expression = unsafe { nil }
+	// Actual build config sent to the agent
+	config BuildConfig
+	// Whether this is a one-time job
+	single bool
+}
+
+// Allows BuildJob structs to be sorted according to their timestamp in
+// MinHeaps
+fn (r1 BuildJob) < (r2 BuildJob) bool {
+	return r1.timestamp < r2.timestamp
+}
+
+// The build job queue is responsible for managing the list of scheduled builds
+// for each architecture. Agents receive jobs from this queue.
+pub struct BuildJobQueue {
+	// Schedule to use for targets without explicitely defined cron expression
+	default_schedule &cron.Expression
+	// Base image to use for targets without defined base image
+	default_base_image string
+	// After how many minutes a build should be forcefully cancelled
+	default_build_timeout int
+mut:
+	mutex shared util.Dummy
+	// For each architecture, a priority queue is tracked
+	queues map[string]MinHeap[BuildJob]
+	// When a target is removed from the server or edited, its previous build
+	// configs will be invalid. This map allows for those to be simply skipped
+	// by ignoring any build configs created before this timestamp.
+	invalidated map[int]time.Time
+}
+
+// new_job_queue initializes a new job queue
+pub fn new_job_queue(default_schedule &cron.Expression, default_base_image string, default_build_timeout int) BuildJobQueue {
+	return BuildJobQueue{
+		default_schedule: unsafe { default_schedule }
+		default_base_image: default_base_image
+		default_build_timeout: default_build_timeout
+		invalidated: map[int]time.Time{}
+	}
+}
+
+// insert_all executes insert for each architecture of the given Target.
+pub fn (mut q BuildJobQueue) insert_all(target Target) ! {
+	for arch in target.arch {
+		q.insert(target: target, arch: arch.value)!
+	}
+}
+
+[params]
+pub struct InsertConfig {
+	target Target [required]
+	arch   string [required]
+	single bool
+	force  bool
+	now    bool
+}
+
+// insert a new target's job into the queue for the given architecture. This
+// job will then be endlessly rescheduled after being pop'ed, unless removed
+// explicitely.
+pub fn (mut q BuildJobQueue) insert(input InsertConfig) ! {
+	lock q.mutex {
+		if input.arch !in q.queues {
+			q.queues[input.arch] = MinHeap[BuildJob]{}
+		}
+
+		mut job := BuildJob{
+			created: time.now()
+			single: input.single
+			config: input.target.as_build_config(q.default_base_image, input.force, q.default_build_timeout)
+		}
+
+		if !input.now {
+			ce := if input.target.schedule != '' {
+				cron.parse_expression(input.target.schedule) or {
+					return error("Error while parsing cron expression '${input.target.schedule}' (id ${input.target.id}): ${err.msg()}")
+				}
+			} else {
+				q.default_schedule
+			}
+
+			job.timestamp = ce.next_from_now()
+			job.ce = ce
+		} else {
+			job.timestamp = time.now()
+		}
+
+		q.queues[input.arch].insert(job)
+	}
+}
+
+// reschedule the given job by calculating the next timestamp and re-adding it
+// to its respective queue. This function is called by the pop functions
+// *after* having pop'ed the job.
+fn (mut q BuildJobQueue) reschedule(job BuildJob, arch string) {
+	new_timestamp := job.ce.next_from_now()
+
+	new_job := BuildJob{
+		...job
+		created: time.now()
+		timestamp: new_timestamp
+	}
+
+	q.queues[arch].insert(new_job)
+}
+
+// pop_invalid pops all invalid jobs.
+fn (mut q BuildJobQueue) pop_invalid(arch string) {
+	for {
+		job := q.queues[arch].peek() or { return }
+
+		if job.config.target_id in q.invalidated
+			&& job.created < q.invalidated[job.config.target_id] {
+			// This pop *should* never fail according to the source code
+			q.queues[arch].pop() or {}
+		} else {
+			break
+		}
+	}
+}
+
+// peek shows the first job for the given architecture that's ready to be
+// executed, if present.
+pub fn (mut q BuildJobQueue) peek(arch string) ?BuildJob {
+	// Even peek requires a write lock, because pop_invalid can modify the data
+	// structure
+	lock q.mutex {
+		if arch !in q.queues {
+			return none
+		}
+
+		q.pop_invalid(arch)
+		job := q.queues[arch].peek() or { return none }
+
+		if job.timestamp < time.now() {
+			return job
+		}
+	}
+
+	return none
+}
+
+// pop removes the first job for the given architecture that's ready to be
+// executed from the queue and returns it, if present.
+pub fn (mut q BuildJobQueue) pop(arch string) ?BuildJob {
+	lock q.mutex {
+		if arch !in q.queues {
+			return none
+		}
+
+		q.pop_invalid(arch)
+		mut job := q.queues[arch].peek() or { return none }
+
+		if job.timestamp < time.now() {
+			job = q.queues[arch].pop() or { return none }
+
+			if !job.single {
+				q.reschedule(job, arch)
+			}
+
+			return job
+		}
+	}
+
+	return none
+}
+
+// pop_n tries to pop at most n available jobs for the given architecture.
+pub fn (mut q BuildJobQueue) pop_n(arch string, n int) []BuildJob {
+	lock q.mutex {
+		if arch !in q.queues {
+			return []
+		}
+
+		mut out := []BuildJob{}
+
+		for out.len < n {
+			q.pop_invalid(arch)
+			mut job := q.queues[arch].peek() or { break }
+
+			if job.timestamp < time.now() {
+				job = q.queues[arch].pop() or { break }
+
+				if !job.single {
+					q.reschedule(job, arch)
+				}
+
+				out << job
+			} else {
+				break
+			}
+		}
+
+		return out
+	}
+
+	return []
+}
+
+// invalidate a target's old build jobs.
+pub fn (mut q BuildJobQueue) invalidate(target_id int) {
+	q.invalidated[target_id] = time.now()
+}

src/build/scripts/git.sh

@@ -4,8 +4,8 @@ echo -e '+ pacman -Syu --needed --noconfirm'
 pacman -Syu --needed --noconfirm
 echo -e '+ su builder'
 su builder
-echo -e '+ git clone --single-branch --depth 1 --branch main https://examplerepo.com repo'
-git clone --single-branch --depth 1 --branch main https://examplerepo.com repo
+echo -e '+ git clone --single-branch --depth 1 '\''https://examplerepo.com'\'' repo'
+git clone --single-branch --depth 1 'https://examplerepo.com' repo
 echo -e '+ cd repo'
 cd repo
 echo -e '+ makepkg --nobuild --syncdeps --needed --noconfirm'
@@ -16,5 +16,5 @@ echo -e '+ curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkg
 curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0
 echo -e '+ [ "$(id -u)" == 0 ] && exit 0'
 [ "$(id -u)" == 0 ] && exit 0
-echo -e '+ MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done'
-MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done
+echo -e '+ MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done'
+MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done

src/build/scripts/git_branch.sh

@@ -0,0 +1,20 @@
+echo -e '+ echo -e '\''[vieter]\\nServer = https://example.com/$repo/$arch\\nSigLevel = Optional'\'' >> /etc/pacman.conf'
+echo -e '[vieter]\nServer = https://example.com/$repo/$arch\nSigLevel = Optional' >> /etc/pacman.conf
+echo -e '+ pacman -Syu --needed --noconfirm'
+pacman -Syu --needed --noconfirm
+echo -e '+ su builder'
+su builder
+echo -e '+ git clone --single-branch --depth 1 --branch main '\''https://examplerepo.com'\'' repo'
+git clone --single-branch --depth 1 --branch main 'https://examplerepo.com' repo
+echo -e '+ cd repo'
+cd repo
+echo -e '+ makepkg --nobuild --syncdeps --needed --noconfirm'
+makepkg --nobuild --syncdeps --needed --noconfirm
+echo -e '+ source PKGBUILD'
+source PKGBUILD
+echo -e '+ curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0'
+curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0
+echo -e '+ [ "$(id -u)" == 0 ] && exit 0'
+[ "$(id -u)" == 0 ] && exit 0
+echo -e '+ MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done'
+MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done

src/build/scripts/git_path.sh

@@ -0,0 +1,20 @@
+echo -e '+ echo -e '\''[vieter]\\nServer = https://example.com/$repo/$arch\\nSigLevel = Optional'\'' >> /etc/pacman.conf'
+echo -e '[vieter]\nServer = https://example.com/$repo/$arch\nSigLevel = Optional' >> /etc/pacman.conf
+echo -e '+ pacman -Syu --needed --noconfirm'
+pacman -Syu --needed --noconfirm
+echo -e '+ su builder'
+su builder
+echo -e '+ git clone --single-branch --depth 1 '\''https://examplerepo.com'\'' repo'
+git clone --single-branch --depth 1 'https://examplerepo.com' repo
+echo -e '+ cd '\''repo/example/path'\'''
+cd 'repo/example/path'
+echo -e '+ makepkg --nobuild --syncdeps --needed --noconfirm'
+makepkg --nobuild --syncdeps --needed --noconfirm
+echo -e '+ source PKGBUILD'
+source PKGBUILD
+echo -e '+ curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0'
+curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0
+echo -e '+ [ "$(id -u)" == 0 ] && exit 0'
+[ "$(id -u)" == 0 ] && exit 0
+echo -e '+ MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done'
+MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done

src/build/scripts/git_path_spaces.sh

@@ -0,0 +1,20 @@
+echo -e '+ echo -e '\''[vieter]\\nServer = https://example.com/$repo/$arch\\nSigLevel = Optional'\'' >> /etc/pacman.conf'
+echo -e '[vieter]\nServer = https://example.com/$repo/$arch\nSigLevel = Optional' >> /etc/pacman.conf
+echo -e '+ pacman -Syu --needed --noconfirm'
+pacman -Syu --needed --noconfirm
+echo -e '+ su builder'
+su builder
+echo -e '+ git clone --single-branch --depth 1 '\''https://examplerepo.com'\'' repo'
+git clone --single-branch --depth 1 'https://examplerepo.com' repo
+echo -e '+ cd '\''repo/example/path with spaces'\'''
+cd 'repo/example/path with spaces'
+echo -e '+ makepkg --nobuild --syncdeps --needed --noconfirm'
+makepkg --nobuild --syncdeps --needed --noconfirm
+echo -e '+ source PKGBUILD'
+source PKGBUILD
+echo -e '+ curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0'
+curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0
+echo -e '+ [ "$(id -u)" == 0 ] && exit 0'
+[ "$(id -u)" == 0 ] && exit 0
+echo -e '+ MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done'
+MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done

src/build/scripts/url.sh

@@ -0,0 +1,22 @@
+echo -e '+ echo -e '\''[vieter]\\nServer = https://example.com/$repo/$arch\\nSigLevel = Optional'\'' >> /etc/pacman.conf'
+echo -e '[vieter]\nServer = https://example.com/$repo/$arch\nSigLevel = Optional' >> /etc/pacman.conf
+echo -e '+ pacman -Syu --needed --noconfirm'
+pacman -Syu --needed --noconfirm
+echo -e '+ su builder'
+su builder
+echo -e '+ mkdir repo'
+mkdir repo
+echo -e '+ curl -o repo/PKGBUILD -L '\''https://examplerepo.com'\'''
+curl -o repo/PKGBUILD -L 'https://examplerepo.com'
+echo -e '+ cd repo'
+cd repo
+echo -e '+ makepkg --nobuild --syncdeps --needed --noconfirm'
+makepkg --nobuild --syncdeps --needed --noconfirm
+echo -e '+ source PKGBUILD'
+source PKGBUILD
+echo -e '+ curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0'
+curl -s --head --fail https://example.com/vieter/x86_64/$pkgname-$pkgver-$pkgrel && exit 0
+echo -e '+ [ "$(id -u)" == 0 ] && exit 0'
+[ "$(id -u)" == 0 ] && exit 0
+echo -e '+ MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done'
+MAKEFLAGS="-j$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in $(ls -1 *.pkg*); do curl -XPOST -T "$pkg" -H "X-API-KEY: $API_KEY" https://example.com/vieter/publish; done

src/build/shell.v

@@ -1,6 +1,6 @@
 module build
 
-import models { GitRepo }
+import models { BuildConfig }
 
 // escape_shell_string escapes any characters that could be interpreted
 // incorrectly by a shell. The resulting value should be safe to use inside an
@@ -22,34 +22,72 @@ pub fn echo_commands(cmds []string) []string {
 	return out
 }
 
-// create_build_script generates a shell script that builds a given GitRepo.
-fn create_build_script(address string, repo &GitRepo, build_arch string) string {
-	repo_url := '$address/$repo.repo'
+// create_build_script generates a shell script that builds a given Target.
+fn create_build_script(address string, config BuildConfig, build_arch string) string {
+	repo_url := '${address}/${config.repo}'
 
-	commands := echo_commands([
+	mut commands := [
 		// This will later be replaced by a proper setting for changing the
 		// mirrorlist
-		"echo -e '[$repo.repo]\\nServer = $address/\$repo/\$arch\\nSigLevel = Optional' >> /etc/pacman.conf"
+		"echo -e '[${config.repo}]\\nServer = ${address}/\$repo/\$arch\\nSigLevel = Optional' >> /etc/pacman.conf"
 		// We need to update the package list of the repo we just added above.
 		// This should however not pull in a lot of packages as long as the
 		// builder image is rebuilt frequently.
 		'pacman -Syu --needed --noconfirm',
 		// makepkg can't run as root
 		'su builder',
-		'git clone --single-branch --depth 1 --branch $repo.branch $repo.url repo',
-		'cd repo',
+	]
+
+	commands << match config.kind {
+		'git' {
+			if config.branch == '' {
+				[
+					"git clone --single-branch --depth 1 '${config.url}' repo",
+				]
+			} else {
+				[
+					"git clone --single-branch --depth 1 --branch ${config.branch} '${config.url}' repo",
+				]
+			}
+		}
+		'url' {
+			[
+				'mkdir repo',
+				"curl -o repo/PKGBUILD -L '${config.url}'",
+			]
+		}
+		else {
+			panic("Invalid kind. This shouldn't be possible.")
+		}
+	}
+
+	commands << if config.path != '' {
+		"cd 'repo/${config.path}'"
+	} else {
+		'cd repo'
+	}
+
+	commands << [
 		'makepkg --nobuild --syncdeps --needed --noconfirm',
 		'source PKGBUILD',
+	]
+
+	if !config.force {
 		// The build container checks whether the package is already present on
 		// the server.
-		'curl -s --head --fail $repo_url/$build_arch/\$pkgname-\$pkgver-\$pkgrel && exit 0',
-		// If the above curl command succeeds, we don't need to rebuild the
-		// package. However, because we're in a su shell, the exit command will
-		// drop us back into the root shell. Therefore, we must check whether
-		// we're in root so we don't proceed.
-		'[ "\$(id -u)" == 0 ] && exit 0',
-		'MAKEFLAGS="-j\$(nproc)" makepkg -s --noconfirm --needed && for pkg in \$(ls -1 *.pkg*); do curl -XPOST -T "\$pkg" -H "X-API-KEY: \$API_KEY" $repo_url/publish; done',
-	])
+		commands << [
+			'curl -s --head --fail ${repo_url}/${build_arch}/\$pkgname-\$pkgver-\$pkgrel && exit 0',
+			// If the above curl command succeeds, we don't need to rebuild the
+			// package. However, because we're in a su shell, the exit command will
+			// drop us back into the root shell. Therefore, we must check whether
+			// we're in root so we don't proceed.
+			'[ "\$(id -u)" == 0 ] && exit 0',
+		]
+	}
 
-	return commands.join('\n')
+	commands << [
+		'MAKEFLAGS="-j\$(nproc)" makepkg -s --noconfirm --needed --noextract && for pkg in \$(ls -1 *.pkg*); do curl -XPOST -T "\$pkg" -H "X-API-KEY: \$API_KEY" ${repo_url}/publish; done',
+	]
+
+	return echo_commands(commands).join('\n')
 }

src/build/shell_test.v

@@ -1,16 +1,75 @@
 module build
 
-import models { GitRepo }
+import models { BuildConfig }
 
-fn test_create_build_script() {
-	repo := GitRepo{
-		id: 1
+fn test_create_build_script_git() {
+	config := BuildConfig{
+		target_id: 1
+		kind: 'git'
 		url: 'https://examplerepo.com'
-		branch: 'main'
 		repo: 'vieter'
+		base_image: 'not-used:latest'
 	}
-	build_script := create_build_script('https://example.com', repo, 'x86_64')
-	expected := $embed_file('build_script.sh')
+
+	build_script := create_build_script('https://example.com', config, 'x86_64')
+	expected := $embed_file('scripts/git.sh')
+
+	assert build_script == expected.to_string().trim_space()
+}
+
+fn test_create_build_script_git_path() {
+	mut config := BuildConfig{
+		target_id: 1
+		kind: 'git'
+		url: 'https://examplerepo.com'
+		repo: 'vieter'
+		path: 'example/path'
+		base_image: 'not-used:latest'
+	}
+
+	mut build_script := create_build_script('https://example.com', config, 'x86_64')
+	mut expected := $embed_file('scripts/git_path.sh')
+
+	assert build_script == expected.to_string().trim_space()
+
+	config = BuildConfig{
+		...config
+		path: 'example/path with spaces'
+	}
+
+	build_script = create_build_script('https://example.com', config, 'x86_64')
+	expected = $embed_file('scripts/git_path_spaces.sh')
+
+	assert build_script == expected.to_string().trim_space()
+}
+
+fn test_create_build_script_git_branch() {
+	config := BuildConfig{
+		target_id: 1
+		kind: 'git'
+		url: 'https://examplerepo.com'
+		branch: 'main'
+		repo: 'vieter'
+		base_image: 'not-used:latest'
+	}
+
+	build_script := create_build_script('https://example.com', config, 'x86_64')
+	expected := $embed_file('scripts/git_branch.sh')
+
+	assert build_script == expected.to_string().trim_space()
+}
+
+fn test_create_build_script_url() {
+	config := BuildConfig{
+		target_id: 1
+		kind: 'url'
+		url: 'https://examplerepo.com'
+		repo: 'vieter'
+		base_image: 'not-used:latest'
+	}
+
+	build_script := create_build_script('https://example.com', config, 'x86_64')
+	expected := $embed_file('scripts/url.sh')
 
 	assert build_script == expected.to_string().trim_space()
 }

src/client/client.v

@@ -2,7 +2,7 @@ module client
 
 import net.http { Method }
 import net.urllib
-import response { Response }
+import web.response { Response, new_data_response }
 import json
 
 pub struct Client {
@@ -21,8 +21,8 @@ pub fn new(address string, api_key string) Client {
 
 // send_request_raw sends an HTTP request, returning the http.Response object.
 // It encodes the params so that they're safe to pass as HTTP query parameters.
-fn (c &Client) send_request_raw(method Method, url string, params map[string]string, body string) ?http.Response {
-	mut full_url := '$c.address$url'
+fn (c &Client) send_request_raw(method Method, url string, params map[string]string, body string) !http.Response {
+	mut full_url := '${c.address}${url}'
 
 	if params.len > 0 {
 		mut params_escaped := map[string]string{}
@@ -30,41 +30,61 @@ fn (c &Client) send_request_raw(method Method, url string, params map[string]str
 		// Escape each query param
 		for k, v in params {
 			// An empty parameter should be the same as not providing it at all
-			if v != '' {
-				params_escaped[k] = urllib.query_escape(v)
-			}
+			params_escaped[k] = urllib.query_escape(v)
 		}
 
-		params_str := params_escaped.keys().map('$it=${params[it]}').join('&')
+		params_str := params_escaped.keys().map('${it}=${params_escaped[it]}').join('&')
 
-		full_url = '$full_url?$params_str'
+		full_url = '${full_url}?${params_str}'
 	}
 
-	mut req := http.new_request(method, full_url, body)?
-	req.add_custom_header('X-Api-Key', c.api_key)?
+	// Looking at the source code, this function doesn't actually fail, so I'm
+	// not sure why it returns an optional
+	mut req := http.new_request(method, full_url, body) or { return error('') }
+	req.add_custom_header('X-Api-Key', c.api_key)!
 
-	res := req.do()?
+	res := req.do()!
 
 	return res
 }
 
 // send_request<T> just calls send_request_with_body<T> with an empty body.
-fn (c &Client) send_request<T>(method Method, url string, params map[string]string) ?Response<T> {
-	return c.send_request_with_body<T>(method, url, params, '')
+fn (c &Client) send_request[T](method Method, url string, params map[string]string) !Response[T] {
+	return c.send_request_with_body[T](method, url, params, '')
 }
 
 // send_request_with_body<T> calls send_request_raw_response & parses its
 // output as a Response<T> object.
-fn (c &Client) send_request_with_body<T>(method Method, url string, params map[string]string, body string) ?Response<T> {
-	res_text := c.send_request_raw_response(method, url, params, body)?
-	data := json.decode(Response<T>, res_text)?
+fn (c &Client) send_request_with_body[T](method Method, url string, params map[string]string, body string) !Response[T] {
+	res := c.send_request_raw(method, url, params, body)!
+	status := res.status()
+
+	// Non-successful requests are expected to return either an empty body or
+	// Response<string>
+	if status.is_error() {
+		// A non-successful status call will have an empty body
+		if res.body == '' {
+			return error('Error ${res.status_code} (${status.str()}): (empty response)')
+		}
+
+		data := json.decode(Response[string], res.body)!
+
+		return error('Status ${res.status_code} (${status.str()}): ${data.message}')
+	}
+
+	// Just return an empty successful response
+	if res.body == '' {
+		return new_data_response(T{})
+	}
+
+	data := json.decode(Response[T], res.body)!
 
 	return data
 }
 
 // send_request_raw_response returns the raw text response for an HTTP request.
-fn (c &Client) send_request_raw_response(method Method, url string, params map[string]string, body string) ?string {
-	res := c.send_request_raw(method, url, params, body)?
+fn (c &Client) send_request_raw_response(method Method, url string, params map[string]string, body string) !string {
+	res := c.send_request_raw(method, url, params, body)!
 
 	return res.body
 }

src/client/git.v

@@ -1,73 +0,0 @@
-module client
-
-import models { GitRepo, GitRepoFilter }
-import net.http { Method }
-import response { Response }
-
-// get_git_repos returns a list of GitRepo's, given a filter object.
-pub fn (c &Client) get_git_repos(filter GitRepoFilter) ?[]GitRepo {
-	params := models.params_from(filter)
-	data := c.send_request<[]GitRepo>(Method.get, '/api/repos', params)?
-
-	return data.data
-}
-
-// get_all_git_repos retrieves *all* GitRepo's from the API using the default
-// limit.
-pub fn (c &Client) get_all_git_repos() ?[]GitRepo {
-	mut repos := []GitRepo{}
-	mut offset := u64(0)
-
-	for {
-		sub_repos := c.get_git_repos(offset: offset)?
-
-		if sub_repos.len == 0 {
-			break
-		}
-
-		repos << sub_repos
-
-		offset += u64(sub_repos.len)
-	}
-
-	return repos
-}
-
-// get_git_repo returns the repo for a specific ID.
-pub fn (c &Client) get_git_repo(id int) ?GitRepo {
-	data := c.send_request<GitRepo>(Method.get, '/api/repos/$id', {})?
-
-	return data.data
-}
-
-// add_git_repo adds a new repo to the server.
-pub fn (c &Client) add_git_repo(url string, branch string, repo string, arch []string) ?Response<string> {
-	mut params := {
-		'url':    url
-		'branch': branch
-		'repo':   repo
-	}
-
-	if arch.len > 0 {
-		params['arch'] = arch.join(',')
-	}
-
-	data := c.send_request<string>(Method.post, '/api/repos', params)?
-
-	return data
-}
-
-// remove_git_repo removes the repo with the given ID from the server.
-pub fn (c &Client) remove_git_repo(id int) ?Response<string> {
-	data := c.send_request<string>(Method.delete, '/api/repos/$id', {})?
-
-	return data
-}
-
-// patch_git_repo sends a PATCH request to the given repo with the params as
-// payload.
-pub fn (c &Client) patch_git_repo(id int, params map[string]string) ?Response<string> {
-	data := c.send_request<string>(Method.patch, '/api/repos/$id', params)?
-
-	return data
-}

src/client/jobs.v

@@ -0,0 +1,23 @@
+module client
+
+import models { BuildConfig }
+
+// poll_jobs requests a list of new build jobs from the server.
+pub fn (c &Client) poll_jobs(arch string, max int) ![]BuildConfig {
+	data := c.send_request[[]BuildConfig](.get, '/api/v1/jobs/poll', {
+		'arch': arch
+		'max':  max.str()
+	})!
+
+	return data.data
+}
+
+// queue_job adds a new one-time build job for the given target to the job
+// queue.
+pub fn (c &Client) queue_job(target_id int, arch string, force bool) ! {
+	c.send_request[string](.post, '/api/v1/jobs/queue', {
+		'target': target_id.str()
+		'arch':   arch
+		'force':  force.str()
+	})!
+}

src/client/logs.v

@@ -1,54 +1,47 @@
 module client
 
 import models { BuildLog, BuildLogFilter }
-import net.http { Method }
-import response { Response }
+import web.response { Response }
 import time
 
 // get_build_logs returns all build logs.
-pub fn (c &Client) get_build_logs(filter BuildLogFilter) ?Response<[]BuildLog> {
+pub fn (c &Client) get_build_logs(filter BuildLogFilter) ![]BuildLog {
 	params := models.params_from(filter)
-	data := c.send_request<[]BuildLog>(Method.get, '/api/logs', params)?
+	data := c.send_request[[]BuildLog](.get, '/api/v1/logs', params)!
 
-	return data
-}
-
-// get_build_logs_for_repo returns all build logs for a given repo.
-pub fn (c &Client) get_build_logs_for_repo(repo_id int) ?Response<[]BuildLog> {
-	params := {
-		'repo': repo_id.str()
-	}
-
-	data := c.send_request<[]BuildLog>(Method.get, '/api/logs', params)?
-
-	return data
+	return data.data
 }
 
 // get_build_log returns a specific build log.
-pub fn (c &Client) get_build_log(id int) ?Response<BuildLog> {
-	data := c.send_request<BuildLog>(Method.get, '/api/logs/$id', {})?
+pub fn (c &Client) get_build_log(id int) !BuildLog {
+	data := c.send_request[BuildLog](.get, '/api/v1/logs/${id}', {})!
 
-	return data
+	return data.data
 }
 
 // get_build_log_content returns the contents of the build log file.
-pub fn (c &Client) get_build_log_content(id int) ?string {
-	data := c.send_request_raw_response(Method.get, '/api/logs/$id/content', {}, '')?
+pub fn (c &Client) get_build_log_content(id int) !string {
+	data := c.send_request_raw_response(.get, '/api/v1/logs/${id}/content', {}, '')!
 
 	return data
 }
 
 // add_build_log adds a new build log to the server.
-pub fn (c &Client) add_build_log(repo_id int, start_time time.Time, end_time time.Time, arch string, exit_code int, content string) ?Response<string> {
+pub fn (c &Client) add_build_log(target_id int, start_time time.Time, end_time time.Time, arch string, exit_code int, content string) !Response[int] {
 	params := {
-		'repo':      repo_id.str()
+		'target':    target_id.str()
 		'startTime': start_time.unix_time().str()
 		'endTime':   end_time.unix_time().str()
 		'arch':      arch
 		'exitCode':  exit_code.str()
 	}
 
-	data := c.send_request_with_body<string>(Method.post, '/api/logs', params, content)?
+	data := c.send_request_with_body[int](.post, '/api/v1/logs', params, content)!
 
 	return data
 }
+
+// remove_build_log removes the build log with the given id from the server.
+pub fn (c &Client) remove_build_log(id int) ! {
+	c.send_request[string](.delete, '/api/v1/logs/${id}', {})!
+}

src/client/repos.v

@@ -0,0 +1,16 @@
+module client
+
+// remove_repo removes an entire repository.
+pub fn (c &Client) remove_repo(repo string) ! {
+	c.send_request[string](.delete, '/${repo}', {})!
+}
+
+// remove_arch_repo removes an entire arch-repo.
+pub fn (c &Client) remove_arch_repo(repo string, arch string) ! {
+	c.send_request[string](.delete, '/${repo}/${arch}', {})!
+}
+
+// remove_package removes a single package from the given arch-repo.
+pub fn (c &Client) remove_package(repo string, arch string, pkgname string) ! {
+	c.send_request[string](.delete, '/${repo}/${arch}/${pkgname}', {})!
+}

src/client/targets.v

@@ -0,0 +1,71 @@
+module client
+
+import models { Target, TargetFilter }
+
+// get_targets returns a list of targets, given a filter object.
+pub fn (c &Client) get_targets(filter TargetFilter) ![]Target {
+	params := models.params_from(filter)
+	data := c.send_request[[]Target](.get, '/api/v1/targets', params)!
+
+	return data.data
+}
+
+// get_all_targets retrieves *all* targs from the API using the default
+// limit.
+pub fn (c &Client) get_all_targets() ![]Target {
+	mut targets := []Target{}
+	mut offset := u64(0)
+
+	for {
+		sub_targets := c.get_targets(offset: offset)!
+
+		if sub_targets.len == 0 {
+			break
+		}
+
+		targets << sub_targets
+
+		offset += u64(sub_targets.len)
+	}
+
+	return targets
+}
+
+// get_target returns the target for a specific id.
+pub fn (c &Client) get_target(id int) !Target {
+	data := c.send_request[Target](.get, '/api/v1/targets/${id}', {})!
+
+	return data.data
+}
+
+pub struct NewTarget {
+	kind   string
+	url    string
+	branch string
+	repo   string
+	path   string
+	arch   []string
+}
+
+// add_target adds a new target to the server.
+pub fn (c &Client) add_target(t NewTarget) !int {
+	params := models.params_from[NewTarget](t)
+	data := c.send_request[int](.post, '/api/v1/targets', params)!
+
+	return data.data
+}
+
+// remove_target removes the target with the given id from the server.
+pub fn (c &Client) remove_target(id int) !string {
+	data := c.send_request[string](.delete, '/api/v1/targets/${id}', {})!
+
+	return data.data
+}
+
+// patch_target sends a PATCH request to the given target with the params as
+// payload.
+pub fn (c &Client) patch_target(id int, params map[string]string) !string {
+	data := c.send_request[string](.patch, '/api/v1/targets/${id}', params)!
+
+	return data.data
+}

src/console/aur/aur.v

@@ -0,0 +1,62 @@
+module aur
+
+import cli
+import console
+import client
+import aur
+import conf as vconf
+
+struct Config {
+	address string [required]
+	api_key string [required]
+}
+
+// cmd returns the cli module for interacting with the AUR API.
+pub fn cmd() cli.Command {
+	return cli.Command{
+		name: 'aur'
+		description: 'Interact with the AUR.'
+		commands: [
+			cli.Command{
+				name: 'search'
+				description: 'Search for packages.'
+				required_args: 1
+				execute: fn (cmd cli.Command) ! {
+					c := aur.new()
+					pkgs := c.search(cmd.args[0])!
+					data := pkgs.map([it.name, it.description])
+
+					println(console.pretty_table(['name', 'description'], data)!)
+				}
+			},
+			cli.Command{
+				name: 'add'
+				usage: 'repo pkg-name [pkg-name...]'
+				description: 'Add the given AUR package(s) to Vieter. Non-existent packages will be silently ignored.'
+				required_args: 2
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					c := aur.new()
+					pkgs := c.info(cmd.args[1..])!
+
+					vc := client.new(conf_.address, conf_.api_key)
+
+					for pkg in pkgs {
+						vc.add_target(
+							kind: 'git'
+							url: 'https://aur.archlinux.org/${pkg.package_base}' + '.git'
+							repo: cmd.args[0]
+						) or {
+							println('Failed to add ${pkg.name}: ${err.msg()}')
+							continue
+						}
+
+						println('Added ${pkg.name}' + '.')
+					}
+				}
+			},
+		]
+	}
+}

src/console/console.v

@@ -5,10 +5,15 @@ import strings
 import cli
 import os
 
+// tabbed_table returns a simple textual table, with tabs as separators.
+pub fn tabbed_table(data [][]string) string {
+	return data.map(it.join('\t')).join('\n')
+}
+
 // pretty_table converts a list of string data into a pretty table. Many thanks
 // to @hungrybluedev in the Vlang Discord for providing this code!
 // https://ptb.discord.com/channels/592103645835821068/592106336838352923/970278787143045192
-pub fn pretty_table(header []string, data [][]string) ?string {
+pub fn pretty_table(header []string, data [][]string) !string {
 	column_count := header.len
 
 	mut column_widths := []int{len: column_count, init: header[it].len}
@@ -21,7 +26,7 @@ pub fn pretty_table(header []string, data [][]string) ?string {
 		}
 	}
 
-	single_line_length := arrays.sum(column_widths)? + (column_count + 1) * 3 - 4
+	single_line_length := arrays.sum(column_widths)! + (column_count + 1) * 3 - 4
 
 	horizontal_line := '+' + strings.repeat(`-`, single_line_length) + '+'
 	mut buffer := strings.new_builder(data.len * single_line_length)
@@ -59,12 +64,12 @@ pub fn pretty_table(header []string, data [][]string) ?string {
 
 // export_man_pages recursively generates all man pages for the given
 // cli.Command & writes them to the given directory.
-pub fn export_man_pages(cmd cli.Command, path string) ? {
+pub fn export_man_pages(cmd cli.Command, path string) ! {
 	man := cmd.manpage()
 	os.write_file(os.join_path_single(path, cmd.full_name().replace(' ', '-') + '.1'),
-		man)?
+		man)!
 
 	for sub_cmd in cmd.commands {
-		export_man_pages(sub_cmd, path)?
+		export_man_pages(sub_cmd, path)!
 	}
 }

src/console/git/build.v

@@ -1,34 +0,0 @@
-module git
-
-import client
-import docker
-import os
-import build
-
-// build builds every Git repo in the server's list.
-fn build(conf Config, repo_id int) ? {
-	c := client.new(conf.address, conf.api_key)
-	repo := c.get_git_repo(repo_id)?
-
-	build_arch := os.uname().machine
-
-	println('Creating base image...')
-	image_id := build.create_build_image(conf.base_image)?
-
-	println('Running build...')
-	res := build.build_repo(conf.address, conf.api_key, image_id, repo)?
-
-	println('Removing build image...')
-
-	mut dd := docker.new_conn()?
-
-	defer {
-		dd.close() or {}
-	}
-
-	dd.remove_image(image_id)?
-
-	println('Uploading logs to Vieter...')
-	c.add_build_log(repo.id, res.start_time, res.end_time, build_arch, res.exit_code,
-		res.logs)?
-}

src/console/git/git.v

@@ -1,229 +0,0 @@
-module git
-
-import cli
-import env
-import cron.expression { parse_expression }
-import client
-import console
-import models { GitRepoFilter }
-
-struct Config {
-	address    string [required]
-	api_key    string [required]
-	base_image string = 'archlinux:base-devel'
-}
-
-// cmd returns the cli submodule that handles the repos API interaction
-pub fn cmd() cli.Command {
-	return cli.Command{
-		name: 'repos'
-		description: 'Interact with the repos API.'
-		commands: [
-			cli.Command{
-				name: 'list'
-				description: 'List the current repos.'
-				flags: [
-					cli.Flag{
-						name: 'limit'
-						description: 'How many results to return.'
-						flag: cli.FlagType.int
-					},
-					cli.Flag{
-						name: 'offset'
-						description: 'Minimum index to return.'
-						flag: cli.FlagType.int
-					},
-					cli.Flag{
-						name: 'repo'
-						description: 'Only return Git repos that publish to this repo.'
-						flag: cli.FlagType.string
-					},
-				]
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
-
-					mut filter := GitRepoFilter{}
-
-					limit := cmd.flags.get_int('limit')?
-					if limit != 0 {
-						filter.limit = u64(limit)
-					}
-
-					offset := cmd.flags.get_int('offset')?
-					if offset != 0 {
-						filter.offset = u64(offset)
-					}
-
-					repo := cmd.flags.get_string('repo')?
-					if repo != '' {
-						filter.repo = repo
-					}
-
-					list(conf, filter)?
-				}
-			},
-			cli.Command{
-				name: 'add'
-				required_args: 3
-				usage: 'url branch repo'
-				description: 'Add a new repository.'
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
-
-					add(conf, cmd.args[0], cmd.args[1], cmd.args[2])?
-				}
-			},
-			cli.Command{
-				name: 'remove'
-				required_args: 1
-				usage: 'id'
-				description: 'Remove a repository that matches the given ID prefix.'
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
-
-					remove(conf, cmd.args[0])?
-				}
-			},
-			cli.Command{
-				name: 'info'
-				required_args: 1
-				usage: 'id'
-				description: 'Show detailed information for the repo matching the ID prefix.'
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
-
-					info(conf, cmd.args[0])?
-				}
-			},
-			cli.Command{
-				name: 'edit'
-				required_args: 1
-				usage: 'id'
-				description: 'Edit the repository that matches the given ID prefix.'
-				flags: [
-					cli.Flag{
-						name: 'url'
-						description: 'URL of the Git repository.'
-						flag: cli.FlagType.string
-					},
-					cli.Flag{
-						name: 'branch'
-						description: 'Branch of the Git repository.'
-						flag: cli.FlagType.string
-					},
-					cli.Flag{
-						name: 'repo'
-						description: 'Repo to publish builds to.'
-						flag: cli.FlagType.string
-					},
-					cli.Flag{
-						name: 'arch'
-						description: 'Comma-separated list of architectures to build on.'
-						flag: cli.FlagType.string
-					},
-					cli.Flag{
-						name: 'schedule'
-						description: 'Cron schedule for repository.'
-						flag: cli.FlagType.string
-					},
-				]
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
-
-					found := cmd.flags.get_all_found()
-
-					mut params := map[string]string{}
-
-					for f in found {
-						if f.name != 'config-file' {
-							params[f.name] = f.get_string()?
-						}
-					}
-
-					patch(conf, cmd.args[0], params)?
-				}
-			},
-			cli.Command{
-				name: 'build'
-				required_args: 1
-				usage: 'id'
-				description: 'Build the repo with the given id & publish it.'
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
-
-					build(conf, cmd.args[0].int())?
-				}
-			},
-		]
-	}
-}
-
-// get_repo_by_prefix tries to find the repo with the given prefix in its
-// ID. If multiple or none are found, an error is raised.
-
-// list prints out a list of all repositories.
-fn list(conf Config, filter GitRepoFilter) ? {
-	c := client.new(conf.address, conf.api_key)
-	repos := c.get_git_repos(filter)?
-	data := repos.map([it.id.str(), it.url, it.branch, it.repo])
-
-	println(console.pretty_table(['id', 'url', 'branch', 'repo'], data)?)
-}
-
-// add adds a new repository to the server's list.
-fn add(conf Config, url string, branch string, repo string) ? {
-	c := client.new(conf.address, conf.api_key)
-	res := c.add_git_repo(url, branch, repo, [])?
-
-	println(res.message)
-}
-
-// remove removes a repository from the server's list.
-fn remove(conf Config, id string) ? {
-	// id, _ := get_repo_by_prefix(conf, id_prefix) ?
-	id_int := id.int()
-
-	if id_int != 0 {
-		c := client.new(conf.address, conf.api_key)
-		res := c.remove_git_repo(id_int)?
-		println(res.message)
-	}
-}
-
-// patch patches a given repository with the provided params.
-fn patch(conf Config, id string, params map[string]string) ? {
-	// We check the cron expression first because it's useless to send an
-	// invalid one to the server.
-	if 'schedule' in params && params['schedule'] != '' {
-		parse_expression(params['schedule']) or {
-			return error('Invalid cron expression: $err.msg()')
-		}
-	}
-
-	id_int := id.int()
-	if id_int != 0 {
-		c := client.new(conf.address, conf.api_key)
-		res := c.patch_git_repo(id_int, params)?
-
-		println(res.message)
-	}
-}
-
-// info shows detailed information for a given repo.
-fn info(conf Config, id string) ? {
-	id_int := id.int()
-
-	if id_int == 0 {
-		return
-	}
-
-	c := client.new(conf.address, conf.api_key)
-	repo := c.get_git_repo(id_int)?
-	println(repo)
-}

src/console/logs/logs.v

@@ -1,7 +1,7 @@
 module logs
 
 import cli
-import env
+import conf as vconf
 import client
 import console
 import time
@@ -12,7 +12,7 @@ struct Config {
 	api_key string [required]
 }
 
-// cmd returns the cli module that handles the build repos API.
+// cmd returns the cli module that handles the build logs API.
 pub fn cmd() cli.Command {
 	return cli.Command{
 		name: 'logs'
@@ -24,31 +24,35 @@ pub fn cmd() cli.Command {
 				flags: [
 					cli.Flag{
 						name: 'limit'
+						abbrev: 'l'
 						description: 'How many results to return.'
 						flag: cli.FlagType.int
 					},
 					cli.Flag{
 						name: 'offset'
+						abbrev: 'o'
 						description: 'Minimum index to return.'
 						flag: cli.FlagType.int
 					},
 					cli.Flag{
-						name: 'repo'
-						description: 'Only return logs for this repo id.'
+						name: 'target'
+						description: 'Only return logs for this target id.'
 						flag: cli.FlagType.int
 					},
 					cli.Flag{
 						name: 'today'
-						description: 'Only list logs started today.'
+						abbrev: 't'
+						description: 'Only list logs started today. This flag overwrites any other date-related flag.'
 						flag: cli.FlagType.bool
 					},
 					cli.Flag{
 						name: 'failed'
-						description: 'Only list logs with non-zero exit codes.'
+						description: 'Only list logs with non-zero exit codes. This flag overwrites the --code flag.'
 						flag: cli.FlagType.bool
 					},
 					cli.Flag{
 						name: 'day'
+						abbrev: 'd'
 						description: 'Only list logs started on this day. (format: YYYY-MM-DD)'
 						flag: cli.FlagType.string
 					},
@@ -62,31 +66,36 @@ pub fn cmd() cli.Command {
 						description: 'Only list logs started after this timestamp. (format: YYYY-MM-DD HH:mm:ss)'
 						flag: cli.FlagType.string
 					},
+					cli.Flag{
+						name: 'code'
+						description: 'Only return logs with the given exit code. Prepend with `!` to exclude instead of include. Can be specified multiple times.'
+						flag: cli.FlagType.string_array
+					},
 				]
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
 
 					mut filter := BuildLogFilter{}
 
-					limit := cmd.flags.get_int('limit')?
+					limit := cmd.flags.get_int('limit')!
 					if limit != 0 {
 						filter.limit = u64(limit)
 					}
 
-					offset := cmd.flags.get_int('offset')?
+					offset := cmd.flags.get_int('offset')!
 					if offset != 0 {
 						filter.offset = u64(offset)
 					}
 
-					repo_id := cmd.flags.get_int('repo')?
-					if repo_id != 0 {
-						filter.repo = repo_id
+					target_id := cmd.flags.get_int('target')!
+					if target_id != 0 {
+						filter.target = target_id
 					}
 
 					tz_offset := time.offset()
 
-					if cmd.flags.get_bool('today')? {
+					if cmd.flags.get_bool('today')! {
 						today := time.now()
 
 						filter.after = time.new_time(time.Time{
@@ -98,12 +107,12 @@ pub fn cmd() cli.Command {
 					}
 					// The -today flag overwrites any of the other date flags.
 					else {
-						day_str := cmd.flags.get_string('day')?
-						before_str := cmd.flags.get_string('before')?
-						after_str := cmd.flags.get_string('after')?
+						day_str := cmd.flags.get_string('day')!
+						before_str := cmd.flags.get_string('before')!
+						after_str := cmd.flags.get_string('after')!
 
 						if day_str != '' {
-							day := time.parse_rfc3339(day_str)?
+							day := time.parse_rfc3339(day_str)!
 							day_utc := time.new_time(time.Time{
 								year: day.year
 								month: day.month
@@ -118,22 +127,38 @@ pub fn cmd() cli.Command {
 							filter.before = day_utc.add_days(1)
 						} else {
 							if before_str != '' {
-								filter.before = time.parse(before_str)?.add_seconds(-tz_offset)
+								filter.before = time.parse(before_str)!.add_seconds(-tz_offset)
 							}
 
 							if after_str != '' {
-								filter.after = time.parse(after_str)?.add_seconds(-tz_offset)
+								filter.after = time.parse(after_str)!.add_seconds(-tz_offset)
 							}
 						}
 					}
 
-					if cmd.flags.get_bool('failed')? {
+					if cmd.flags.get_bool('failed')! {
 						filter.exit_codes = [
 							'!0',
 						]
+					} else {
+						filter.exit_codes = cmd.flags.get_strings('code')!
 					}
 
-					list(conf, filter)?
+					raw := cmd.flags.get_bool('raw')!
+
+					list(conf_, filter, raw)!
+				}
+			},
+			cli.Command{
+				name: 'remove'
+				required_args: 1
+				usage: 'id'
+				description: 'Remove a build log that matches the given id.'
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					remove(conf_, cmd.args[0])!
 				}
 			},
 			cli.Command{
@@ -141,12 +166,12 @@ pub fn cmd() cli.Command {
 				required_args: 1
 				usage: 'id'
 				description: 'Show all info for a specific build log.'
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
 
 					id := cmd.args[0].int()
-					info(conf, id)?
+					info(conf_, id)!
 				}
 			},
 			cli.Command{
@@ -154,12 +179,12 @@ pub fn cmd() cli.Command {
 				required_args: 1
 				usage: 'id'
 				description: 'Output the content of a build log to stdout.'
-				execute: fn (cmd cli.Command) ? {
-					config_file := cmd.flags.get_string('config-file')?
-					conf := env.load<Config>(config_file)?
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
 
 					id := cmd.args[0].int()
-					content(conf, id)?
+					content(conf_, id)!
 				}
 			},
 		]
@@ -167,42 +192,44 @@ pub fn cmd() cli.Command {
 }
 
 // print_log_list prints a list of logs.
-fn print_log_list(logs []BuildLog) ? {
-	data := logs.map([it.id.str(), it.repo_id.str(), it.start_time.local().str(),
+fn print_log_list(logs []BuildLog, raw bool) ! {
+	data := logs.map([it.id.str(), it.target_id.str(), it.start_time.local().str(),
 		it.exit_code.str()])
 
-	println(console.pretty_table(['id', 'repo', 'start time', 'exit code'], data)?)
+	if raw {
+		println(console.tabbed_table(data))
+	} else {
+		println(console.pretty_table(['id', 'target', 'start time', 'exit code'], data)!)
+	}
 }
 
 // list prints a list of all build logs.
-fn list(conf Config, filter BuildLogFilter) ? {
-	c := client.new(conf.address, conf.api_key)
-	logs := c.get_build_logs(filter)?.data
+fn list(conf_ Config, filter BuildLogFilter, raw bool) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	logs := c.get_build_logs(filter)!
 
-	print_log_list(logs)?
-}
-
-// list prints a list of all build logs for a given repo.
-fn list_for_repo(conf Config, repo_id int) ? {
-	c := client.new(conf.address, conf.api_key)
-	logs := c.get_build_logs_for_repo(repo_id)?.data
-
-	print_log_list(logs)?
+	print_log_list(logs, raw)!
 }
 
 // info print the detailed info for a given build log.
-fn info(conf Config, id int) ? {
-	c := client.new(conf.address, conf.api_key)
-	log := c.get_build_log(id)?.data
+fn info(conf_ Config, id int) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	log := c.get_build_log(id)!
 
 	print(log)
 }
 
 // content outputs the contents of the log file for a given build log to
 // stdout.
-fn content(conf Config, id int) ? {
-	c := client.new(conf.address, conf.api_key)
-	content := c.get_build_log_content(id)?
+fn content(conf_ Config, id int) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	content := c.get_build_log_content(id)!
 
 	println(content)
 }
+
+// remove removes a build log from the server's list.
+fn remove(conf_ Config, id string) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	c.remove_build_log(id.int())!
+}

src/console/man/man.v

@@ -11,11 +11,11 @@ pub fn cmd() cli.Command {
 		description: 'Generate all man pages & save them in the given directory.'
 		usage: 'dir'
 		required_args: 1
-		execute: fn (cmd cli.Command) ? {
+		execute: fn (cmd cli.Command) ! {
 			root := cmd.root()
-			os.mkdir_all(cmd.args[0])?
+			os.mkdir_all(cmd.args[0])!
 
-			console.export_man_pages(root, cmd.args[0])?
+			console.export_man_pages(root, cmd.args[0])!
 		}
 	}
 }

src/console/repos/repos.v

@@ -0,0 +1,52 @@
+module repos
+
+import cli
+import conf as vconf
+import client
+
+struct Config {
+	address string [required]
+	api_key string [required]
+}
+
+// cmd returns the cli module that handles modifying the repository contents.
+pub fn cmd() cli.Command {
+	return cli.Command{
+		name: 'repos'
+		description: 'Interact with the repositories & packages stored on the server.'
+		commands: [
+			cli.Command{
+				name: 'remove'
+				required_args: 1
+				usage: 'repo [arch [pkgname]]'
+				description: 'Remove a repo, arch-repo, or package from the server.'
+				flags: [
+					cli.Flag{
+						name: 'force'
+						flag: cli.FlagType.bool
+					},
+				]
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					if cmd.args.len < 3 {
+						if !cmd.flags.get_bool('force')! {
+							return error('Removing an arch-repo or repository is a very destructive command. If you really do wish to perform this operation, explicitely add the --force flag.')
+						}
+					}
+
+					client_ := client.new(conf_.address, conf_.api_key)
+
+					if cmd.args.len == 1 {
+						client_.remove_repo(cmd.args[0])!
+					} else if cmd.args.len == 2 {
+						client_.remove_arch_repo(cmd.args[0], cmd.args[1])!
+					} else {
+						client_.remove_package(cmd.args[0], cmd.args[1], cmd.args[2])!
+					}
+				}
+			},
+		]
+	}
+}

src/console/schedule/schedule.v

@@ -1,7 +1,7 @@
 module schedule
 
 import cli
-import cron.expression { parse_expression }
+import cron
 import time
 
 // cmd returns the cli submodule for previewing a cron schedule.
@@ -18,11 +18,11 @@ pub fn cmd() cli.Command {
 				default_value: ['5']
 			},
 		]
-		execute: fn (cmd cli.Command) ? {
-			ce := parse_expression(cmd.args.join(' '))?
-			count := cmd.flags.get_int('count')?
+		execute: fn (cmd cli.Command) ! {
+			ce := cron.parse_expression(cmd.args.join(' '))!
+			count := cmd.flags.get_int('count')!
 
-			for t in ce.next_n(time.now(), count)? {
+			for t in ce.next_n(time.now(), count) {
 				println(t)
 			}
 		}

src/console/targets/build.v

@@ -0,0 +1,34 @@
+module targets
+
+import client
+import docker
+import os
+import build
+
+// build locally builds the target with the given id.
+fn build_target(conf Config, target_id int, force bool, timeout int) ! {
+	c := client.new(conf.address, conf.api_key)
+	target := c.get_target(target_id)!
+
+	build_arch := os.uname().machine
+
+	println('Creating base image...')
+	image_id := build.create_build_image(conf.base_image)!
+
+	println('Running build...')
+	res := build.build_target(conf.address, conf.api_key, image_id, target, force, timeout)!
+
+	println('Removing build image...')
+
+	mut dd := docker.new_conn()!
+
+	defer {
+		dd.close() or {}
+	}
+
+	dd.image_remove(image_id)!
+
+	println('Uploading logs to Vieter...')
+	c.add_build_log(target.id, res.start_time, res.end_time, build_arch, res.exit_code,
+		res.logs)!
+}

src/console/targets/targets.v

@@ -0,0 +1,319 @@
+module targets
+
+import cli
+import conf as vconf
+import cron
+import client { NewTarget }
+import console
+import models { TargetFilter }
+
+struct Config {
+	address    string [required]
+	api_key    string [required]
+	base_image string = 'archlinux:base-devel'
+}
+
+// cmd returns the cli submodule that handles the targets API interaction
+pub fn cmd() cli.Command {
+	return cli.Command{
+		name: 'targets'
+		description: 'Interact with the targets API.'
+		commands: [
+			cli.Command{
+				name: 'list'
+				description: 'List the current targets.'
+				flags: [
+					cli.Flag{
+						name: 'limit'
+						abbrev: 'l'
+						description: 'How many results to return.'
+						flag: cli.FlagType.int
+					},
+					cli.Flag{
+						name: 'offset'
+						abbrev: 'o'
+						description: 'Minimum index to return.'
+						flag: cli.FlagType.int
+					},
+					cli.Flag{
+						name: 'repo'
+						description: 'Only return targets that publish to this repo.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'query'
+						abbrev: 'q'
+						description: 'Search string to filter targets by.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'arch'
+						description: 'Only list targets that build for this arch.'
+						flag: cli.FlagType.string
+					},
+				]
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					mut filter := TargetFilter{}
+
+					limit := cmd.flags.get_int('limit')!
+					if limit != 0 {
+						filter.limit = u64(limit)
+					}
+
+					offset := cmd.flags.get_int('offset')!
+					if offset != 0 {
+						filter.offset = u64(offset)
+					}
+
+					repo := cmd.flags.get_string('repo')!
+					if repo != '' {
+						filter.repo = repo
+					}
+
+					query := cmd.flags.get_string('query')!
+					if query != '' {
+						filter.query = query
+					}
+
+					arch := cmd.flags.get_string('arch')!
+					if arch != '' {
+						filter.arch = arch
+					}
+
+					raw := cmd.flags.get_bool('raw')!
+
+					list(conf_, filter, raw)!
+				}
+			},
+			cli.Command{
+				name: 'add'
+				required_args: 2
+				usage: 'url repo'
+				description: 'Add a new target with the given URL & target repo.'
+				flags: [
+					cli.Flag{
+						name: 'kind'
+						description: "Kind of target to add. Defaults to 'git' if not specified. One of 'git', 'url'."
+						flag: cli.FlagType.string
+						default_value: ['git']
+					},
+					cli.Flag{
+						name: 'branch'
+						description: "Which branch to clone; only applies to kind 'git'."
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'path'
+						description: 'Subdirectory inside Git repository to use.'
+						flag: cli.FlagType.string
+					},
+				]
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					t := NewTarget{
+						kind: cmd.flags.get_string('kind')!
+						url: cmd.args[0]
+						repo: cmd.args[1]
+						branch: cmd.flags.get_string('branch') or { '' }
+						path: cmd.flags.get_string('path') or { '' }
+					}
+
+					raw := cmd.flags.get_bool('raw')!
+
+					add(conf_, t, raw)!
+				}
+			},
+			cli.Command{
+				name: 'remove'
+				required_args: 1
+				usage: 'id'
+				description: 'Remove a target that matches the given id.'
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					remove(conf_, cmd.args[0])!
+				}
+			},
+			cli.Command{
+				name: 'info'
+				required_args: 1
+				usage: 'id'
+				description: 'Show detailed information for the target matching the id.'
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					info(conf_, cmd.args[0])!
+				}
+			},
+			cli.Command{
+				name: 'edit'
+				required_args: 1
+				usage: 'id'
+				description: 'Edit the target that matches the given id.'
+				flags: [
+					cli.Flag{
+						name: 'url'
+						description: 'URL value. Meaning depends on kind of target.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'branch'
+						description: 'Branch of the Git repository.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'repo'
+						description: 'Repo to publish builds to.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'arch'
+						description: 'Comma-separated list of architectures to build on.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'schedule'
+						description: 'Cron schedule for repository.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'kind'
+						description: 'Kind of target.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'path'
+						description: 'Subdirectory inside Git repository to use.'
+						flag: cli.FlagType.string
+					},
+				]
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					found := cmd.flags.get_all_found()
+
+					mut params := map[string]string{}
+
+					for f in found {
+						if f.name != 'config-file' {
+							params[f.name] = f.get_string()!
+						}
+					}
+
+					patch(conf_, cmd.args[0], params)!
+				}
+			},
+			cli.Command{
+				name: 'build'
+				required_args: 1
+				usage: 'id'
+				description: 'Build the target with the given id & publish it.'
+				flags: [
+					cli.Flag{
+						name: 'force'
+						description: 'Build the target without checking whether it needs to be renewed.'
+						flag: cli.FlagType.bool
+					},
+					cli.Flag{
+						name: 'remote'
+						description: 'Schedule the build on the server instead of running it locally.'
+						flag: cli.FlagType.bool
+					},
+					cli.Flag{
+						name: 'arch'
+						description: 'Architecture to schedule build for. Required when using -remote.'
+						flag: cli.FlagType.string
+					},
+					cli.Flag{
+						name: 'timeout'
+						description: 'After how many minutes to cancel the build. Only applies to local builds.'
+						flag: cli.FlagType.int
+						default_value: ['3600']
+					},
+				]
+				execute: fn (cmd cli.Command) ! {
+					config_file := cmd.flags.get_string('config-file')!
+					conf_ := vconf.load[Config](prefix: 'VIETER_', default_path: config_file)!
+
+					remote := cmd.flags.get_bool('remote')!
+					force := cmd.flags.get_bool('force')!
+					timeout := cmd.flags.get_int('timeout')!
+					target_id := cmd.args[0].int()
+
+					if remote {
+						arch := cmd.flags.get_string('arch')!
+
+						if arch == '' {
+							return error('When scheduling the build remotely, you have to specify an architecture.')
+						}
+
+						c := client.new(conf_.address, conf_.api_key)
+						c.queue_job(target_id, arch, force)!
+					} else {
+						build_target(conf_, target_id, force, timeout)!
+					}
+				}
+			},
+		]
+	}
+}
+
+// list prints out a list of all repositories.
+fn list(conf_ Config, filter TargetFilter, raw bool) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	targets := c.get_targets(filter)!
+	data := targets.map([it.id.str(), it.kind, it.url, it.repo])
+
+	if raw {
+		println(console.tabbed_table(data))
+	} else {
+		println(console.pretty_table(['id', 'kind', 'url', 'repo'], data)!)
+	}
+}
+
+// add adds a new target to the server's list.
+fn add(conf_ Config, t &NewTarget, raw bool) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	target_id := c.add_target(t)!
+
+	if raw {
+		println(target_id)
+	} else {
+		println('Target added with id ${target_id}')
+	}
+}
+
+// remove removes a target from the server's list.
+fn remove(conf_ Config, id string) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	c.remove_target(id.int())!
+}
+
+// patch patches a given target with the provided params.
+fn patch(conf_ Config, id string, params map[string]string) ! {
+	// We check the cron expression first because it's useless to send an
+	// invalid one to the server.
+	if 'schedule' in params && params['schedule'] != '' {
+		cron.parse_expression(params['schedule']) or {
+			return error('Invalid cron expression: ${err.msg()}')
+		}
+	}
+
+	c := client.new(conf_.address, conf_.api_key)
+	c.patch_target(id.int(), params)!
+}
+
+// info shows detailed information for a given target.
+fn info(conf_ Config, id string) ! {
+	c := client.new(conf_.address, conf_.api_key)
+	target := c.get_target(id.int())!
+	println(target)
+}

src/cron/cli.v

@@ -1,32 +0,0 @@
-module cron
-
-import cli
-import env
-
-struct Config {
-pub:
-	log_level               string = 'WARN'
-	api_key                 string
-	address                 string
-	data_dir                string
-	base_image              string = 'archlinux:base-devel'
-	max_concurrent_builds   int    = 1
-	api_update_frequency    int    = 15
-	image_rebuild_frequency int    = 1440
-	// Replicates the behavior of the original cron system
-	global_schedule string = '0 3'
-}
-
-// cmd returns the cli module that handles the cron daemon.
-pub fn cmd() cli.Command {
-	return cli.Command{
-		name: 'cron'
-		description: 'Start the cron service that periodically runs builds.'
-		execute: fn (cmd cli.Command) ? {
-			config_file := cmd.flags.get_string('config-file')?
-			conf := env.load<Config>(config_file)?
-
-			cron(conf)?
-		}
-	}
-}

src/cron/cron.v

@@ -1,33 +0,0 @@
-module cron
-
-import log
-import cron.daemon
-import cron.expression
-import os
-
-const log_file_name = 'vieter.cron.log'
-
-// cron starts a cron daemon & starts periodically scheduling builds.
-pub fn cron(conf Config) ? {
-	// Configure logger
-	log_level := log.level_from_tag(conf.log_level) or {
-		return error('Invalid log level. The allowed values are FATAL, ERROR, WARN, INFO & DEBUG.')
-	}
-
-	mut logger := log.Log{
-		level: log_level
-	}
-
-	log_file := os.join_path_single(conf.data_dir, cron.log_file_name)
-	logger.set_full_logpath(log_file)
-	logger.log_to_console_too()
-
-	ce := expression.parse_expression(conf.global_schedule) or {
-		return error('Error while parsing global cron expression: $err.msg()')
-	}
-
-	mut d := daemon.init_daemon(logger, conf.address, conf.api_key, conf.base_image, ce,
-		conf.max_concurrent_builds, conf.api_update_frequency, conf.image_rebuild_frequency)?
-
-	d.run()
-}

src/cron/daemon/build.v

@@ -1,113 +0,0 @@
-module daemon
-
-import time
-import sync.stdatomic
-import build
-import os
-
-const (
-	build_empty   = 0
-	build_running = 1
-	build_done    = 2
-)
-
-// clean_finished_builds removes finished builds from the build slots & returns
-// them.
-fn (mut d Daemon) clean_finished_builds() []ScheduledBuild {
-	mut out := []ScheduledBuild{}
-
-	for i in 0 .. d.atomics.len {
-		if stdatomic.load_u64(&d.atomics[i]) == daemon.build_done {
-			stdatomic.store_u64(&d.atomics[i], daemon.build_empty)
-			out << d.builds[i]
-		}
-	}
-
-	return out
-}
-
-// update_builds starts as many builds as possible.
-fn (mut d Daemon) start_new_builds() {
-	now := time.now()
-
-	for d.queue.len() > 0 {
-		elem := d.queue.peek() or {
-			d.lerror("queue.peek() unexpectedly returned an error. This shouldn't happen.")
-
-			break
-		}
-
-		if elem.timestamp < now {
-			sb := d.queue.pop() or {
-				d.lerror("queue.pop() unexpectedly returned an error. This shouldn't happen.")
-
-				break
-			}
-
-			// If this build couldn't be scheduled, no more will be possible.
-			if !d.start_build(sb) {
-				d.queue.insert(sb)
-				break
-			}
-		} else {
-			break
-		}
-	}
-}
-
-// start_build starts a build for the given ScheduledBuild object.
-fn (mut d Daemon) start_build(sb ScheduledBuild) bool {
-	for i in 0 .. d.atomics.len {
-		if stdatomic.load_u64(&d.atomics[i]) == daemon.build_empty {
-			stdatomic.store_u64(&d.atomics[i], daemon.build_running)
-			d.builds[i] = sb
-
-			go d.run_build(i, sb)
-
-			return true
-		}
-	}
-
-	return false
-}
-
-// run_build actually starts the build process for a given repo.
-fn (mut d Daemon) run_build(build_index int, sb ScheduledBuild) {
-	d.linfo('started build: $sb.repo.url $sb.repo.branch')
-
-	// 0 means success, 1 means failure
-	mut status := 0
-
-	res := build.build_repo(d.client.address, d.client.api_key, d.builder_images.last(),
-		&sb.repo) or {
-		d.ldebug('build_repo error: $err.msg()')
-		status = 1
-
-		build.BuildResult{}
-	}
-
-	if status == 0 {
-		d.linfo('finished build: $sb.repo.url $sb.repo.branch; uploading logs...')
-
-		build_arch := os.uname().machine
-		d.client.add_build_log(sb.repo.id, res.start_time, res.end_time, build_arch, res.exit_code,
-			res.logs) or { d.lerror('Failed to upload logs for $sb.repo.url $sb.repo.arch') }
-	} else {
-		d.linfo('failed build: $sb.repo.url $sb.repo.branch')
-	}
-
-	stdatomic.store_u64(&d.atomics[build_index], daemon.build_done)
-}
-
-// current_build_count returns how many builds are currently running.
-fn (mut d Daemon) current_build_count() int {
-	mut res := 0
-
-	for i in 0 .. d.atomics.len {
-		if stdatomic.load_u64(&d.atomics[i]) == daemon.build_running {
-			res += 1
-		}
-	}
-
-	return res
-}

src/cron/daemon/daemon.v

@@ -1,273 +0,0 @@
-module daemon
-
-import time
-import log
-import datatypes { MinHeap }
-import cron.expression { CronExpression, parse_expression }
-import math
-import build
-import docker
-import os
-import client
-import models { GitRepo }
-
-const (
-	// How many seconds to wait before retrying to update API if failed
-	api_update_retry_timeout        = 5
-	// How many seconds to wait before retrying to rebuild image if failed
-	rebuild_base_image_retry_timout = 30
-)
-
-struct ScheduledBuild {
-pub:
-	repo      GitRepo
-	timestamp time.Time
-}
-
-// Overloaded operator for comparing ScheduledBuild objects
-fn (r1 ScheduledBuild) < (r2 ScheduledBuild) bool {
-	return r1.timestamp < r2.timestamp
-}
-
-pub struct Daemon {
-mut:
-	client                  client.Client
-	base_image              string
-	builder_images          []string
-	global_schedule         CronExpression
-	api_update_frequency    int
-	image_rebuild_frequency int
-	// Repos currently loaded from API.
-	repos []GitRepo
-	// At what point to update the list of repositories.
-	api_update_timestamp  time.Time
-	image_build_timestamp time.Time
-	queue                 MinHeap<ScheduledBuild>
-	// Which builds are currently running
-	builds []ScheduledBuild
-	// Atomic variables used to detect when a build has finished; length is the
-	// same as builds
-	atomics []u64
-	logger  shared log.Log
-}
-
-// init_daemon initializes a new Daemon object. It renews the repositories &
-// populates the build queue for the first time.
-pub fn init_daemon(logger log.Log, address string, api_key string, base_image string, global_schedule CronExpression, max_concurrent_builds int, api_update_frequency int, image_rebuild_frequency int) ?Daemon {
-	mut d := Daemon{
-		client: client.new(address, api_key)
-		base_image: base_image
-		global_schedule: global_schedule
-		api_update_frequency: api_update_frequency
-		image_rebuild_frequency: image_rebuild_frequency
-		atomics: []u64{len: max_concurrent_builds}
-		builds: []ScheduledBuild{len: max_concurrent_builds}
-		logger: logger
-	}
-
-	// Initialize the repos & queue
-	d.renew_repos()
-	d.renew_queue()
-	if !d.rebuild_base_image() {
-		return error('The base image failed to build. The Vieter cron daemon cannot run without an initial builder image.')
-	}
-
-	return d
-}
-
-// run starts the actual daemon process. It runs builds when possible &
-// periodically refreshes the list of repositories to ensure we stay in sync.
-pub fn (mut d Daemon) run() {
-	for {
-		finished_builds := d.clean_finished_builds()
-
-		// Update the API's contents if needed & renew the queue
-		if time.now() >= d.api_update_timestamp {
-			d.renew_repos()
-			d.renew_queue()
-		}
-		// The finished builds should only be rescheduled if the API contents
-		// haven't been renewed.
-		else {
-			for sb in finished_builds {
-				d.schedule_build(sb.repo)
-			}
-		}
-
-		// TODO remove old builder images.
-		// This issue is less trivial than it sounds, because a build could
-		// still be running when the image has to be rebuilt. That would
-		// prevent the image from being removed. Therefore, we will need to
-		// keep track of a list or something & remove an image once we have
-		// made sure it isn't being used anymore.
-		if time.now() >= d.image_build_timestamp {
-			d.rebuild_base_image()
-			// In theory, executing this function here allows an old builder
-			// image to exist for at most image_rebuild_frequency minutes.
-			d.clean_old_base_images()
-		}
-
-		// Schedules new builds when possible
-		d.start_new_builds()
-
-		// If there are builds currently running, the daemon should refresh
-		// every second to clean up any finished builds & start new ones.
-		mut delay := time.Duration(1 * time.second)
-
-		// Sleep either until we have to refresh the repos or when the next
-		// build has to start, with a minimum of 1 second.
-		if d.current_build_count() == 0 {
-			now := time.now()
-			delay = d.api_update_timestamp - now
-
-			if d.queue.len() > 0 {
-				elem := d.queue.peek() or {
-					d.lerror("queue.peek() unexpectedly returned an error. This shouldn't happen.")
-
-					// This is just a fallback option. In theory, queue.peek()
-					// should *never* return an error or none, because we check
-					// its len beforehand.
-					time.sleep(1)
-					continue
-				}
-
-				time_until_next_job := elem.timestamp - now
-
-				delay = math.min(delay, time_until_next_job)
-			}
-		}
-
-		// We sleep for at least one second. This is to prevent the program
-		// from looping agressively when a cronjob can be scheduled, but
-		// there's no spots free for it to be started.
-		delay = math.max(delay, 1 * time.second)
-
-		d.ldebug('Sleeping for ${delay}...')
-
-		time.sleep(delay)
-	}
-}
-
-// schedule_build adds the next occurence of the given repo build to the queue.
-fn (mut d Daemon) schedule_build(repo GitRepo) {
-	ce := if repo.schedule != '' {
-		parse_expression(repo.schedule) or {
-			// TODO This shouldn't return an error if the expression is empty.
-			d.lerror("Error while parsing cron expression '$repo.schedule' (id $repo.id): $err.msg()")
-
-			d.global_schedule
-		}
-	} else {
-		d.global_schedule
-	}
-
-	// A repo that can't be scheduled will just be skipped for now
-	timestamp := ce.next_from_now() or {
-		d.lerror("Couldn't calculate next timestamp from '$repo.schedule'; skipping")
-		return
-	}
-
-	d.queue.insert(ScheduledBuild{
-		repo: repo
-		timestamp: timestamp
-	})
-}
-
-// renew_repos requests the newest list of Git repos from the server & replaces
-// the old one.
-fn (mut d Daemon) renew_repos() {
-	d.linfo('Renewing repos...')
-
-	mut new_repos := d.client.get_all_git_repos() or {
-		d.lerror('Failed to renew repos. Retrying in ${daemon.api_update_retry_timeout}s...')
-		d.api_update_timestamp = time.now().add_seconds(daemon.api_update_retry_timeout)
-
-		return
-	}
-
-	// Filter out any repos that shouldn't run on this architecture
-	cur_arch := os.uname().machine
-	new_repos = new_repos.filter(it.arch.any(it.value == cur_arch))
-
-	d.repos = new_repos
-
-	d.api_update_timestamp = time.now().add_seconds(60 * d.api_update_frequency)
-}
-
-// renew_queue replaces the old queue with a new one that reflects the newest
-// values in repos_map.
-fn (mut d Daemon) renew_queue() {
-	d.linfo('Renewing queue...')
-	mut new_queue := MinHeap<ScheduledBuild>{}
-
-	// Move any jobs that should have already started from the old queue onto
-	// the new one
-	now := time.now()
-
-	// For some reason, using
-	// ```v
-	// for d.queue.len() > 0 && d.queue.peek() ?.timestamp < now {
-	//```
-	// here causes the function to prematurely just exit, without any errors or anything, very weird
-	// https://github.com/vlang/v/issues/14042
-	for d.queue.len() > 0 {
-		elem := d.queue.pop() or {
-			d.lerror("queue.pop() returned an error. This shouldn't happen.")
-			continue
-		}
-
-		if elem.timestamp < now {
-			new_queue.insert(elem)
-		} else {
-			break
-		}
-	}
-
-	d.queue = new_queue
-
-	// For each repository in repos_map, parse their cron expression (or use
-	// the default one if not present) & add them to the queue
-	for repo in d.repos {
-		d.schedule_build(repo)
-	}
-}
-
-// rebuild_base_image recreates the builder image.
-fn (mut d Daemon) rebuild_base_image() bool {
-	d.linfo('Rebuilding builder image....')
-
-	d.builder_images << build.create_build_image(d.base_image) or {
-		d.lerror('Failed to rebuild base image. Retrying in ${daemon.rebuild_base_image_retry_timout}s...')
-		d.image_build_timestamp = time.now().add_seconds(daemon.rebuild_base_image_retry_timout)
-
-		return false
-	}
-
-	d.image_build_timestamp = time.now().add_seconds(60 * d.image_rebuild_frequency)
-
-	return true
-}
-
-// clean_old_base_images tries to remove any old but still present builder
-// images.
-fn (mut d Daemon) clean_old_base_images() {
-	mut i := 0
-
-	mut dd := docker.new_conn() or {
-		d.lerror('Failed to connect to Docker socket.')
-		return
-	}
-
-	defer {
-		dd.close() or {}
-	}
-
-	for i < d.builder_images.len - 1 {
-		// For each builder image, we try to remove it by calling the Docker
-		// API. If the function returns an error or false, that means the image
-		// wasn't deleted. Therefore, we move the index over. If the function
-		// returns true, the array's length has decreased by one so we don't
-		// move the index.
-		dd.remove_image(d.builder_images[i]) or { i += 1 }
-	}
-}

src/cron/daemon/log.v

@@ -1,35 +0,0 @@
-module daemon
-
-import log
-
-// log reate a log message with the given level
-pub fn (mut d Daemon) log(msg &string, level log.Level) {
-	lock d.logger {
-		d.logger.send_output(msg, level)
-	}
-}
-
-// lfatal create a log message with the fatal level
-pub fn (mut d Daemon) lfatal(msg &string) {
-	d.log(msg, log.Level.fatal)
-}
-
-// lerror create a log message with the error level
-pub fn (mut d Daemon) lerror(msg &string) {
-	d.log(msg, log.Level.error)
-}
-
-// lwarn create a log message with the warn level
-pub fn (mut d Daemon) lwarn(msg &string) {
-	d.log(msg, log.Level.warn)
-}
-
-// linfo create a log message with the info level
-pub fn (mut d Daemon) linfo(msg &string) {
-	d.log(msg, log.Level.info)
-}
-
-// ldebug create a log message with the debug level
-pub fn (mut d Daemon) ldebug(msg &string) {
-	d.log(msg, log.Level.debug)
-}

src/cron/expression.c.v

@@ -0,0 +1,101 @@
+module cron
+
+#flag -I @VMODROOT/libvieter/include
+#flag -L @VMODROOT/libvieter/build
+#flag -lvieter
+#include "vieter_cron.h"
+
+[typedef]
+pub struct C.vieter_cron_expression {
+	minutes      &u8
+	hours        &u8
+	days         &u8
+	months       &u8
+	minute_count u8
+	hour_count   u8
+	day_count    u8
+	month_count  u8
+}
+
+pub type Expression = C.vieter_cron_expression
+
+// == returns whether the two expressions are equal by value.
+fn (ce1 Expression) == (ce2 Expression) bool {
+	if ce1.month_count != ce2.month_count || ce1.day_count != ce2.day_count
+		|| ce1.hour_count != ce2.hour_count || ce1.minute_count != ce2.minute_count {
+		return false
+	}
+
+	for i in 0 .. ce1.month_count {
+		unsafe {
+			if ce1.months[i] != ce2.months[i] {
+				return false
+			}
+		}
+	}
+	for i in 0 .. ce1.day_count {
+		unsafe {
+			if ce1.days[i] != ce2.days[i] {
+				return false
+			}
+		}
+	}
+	for i in 0 .. ce1.hour_count {
+		unsafe {
+			if ce1.hours[i] != ce2.hours[i] {
+				return false
+			}
+		}
+	}
+	for i in 0 .. ce1.minute_count {
+		unsafe {
+			if ce1.minutes[i] != ce2.minutes[i] {
+				return false
+			}
+		}
+	}
+
+	return true
+}
+
+[typedef]
+struct C.vieter_cron_simple_time {
+	year   int
+	month  int
+	day    int
+	hour   int
+	minute int
+}
+
+type SimpleTime = C.vieter_cron_simple_time
+
+enum ParseError as u8 {
+	ok = 0
+	invalid_expression = 1
+	invalid_number = 2
+	out_of_range = 3
+	too_many_parts = 4
+	not_enough_parts = 5
+}
+
+// str returns the string representation of a ParseError.
+fn (e ParseError) str() string {
+	return match e {
+		.ok { '' }
+		.invalid_expression { 'Invalid expression' }
+		.invalid_number { 'Invalid number' }
+		.out_of_range { 'Out of range' }
+		.too_many_parts { 'Too many parts' }
+		.not_enough_parts { 'Not enough parts' }
+	}
+}
+
+fn C.vieter_cron_expr_init() &C.vieter_cron_expression
+
+fn C.vieter_cron_expr_free(ce &C.vieter_cron_expression)
+
+fn C.vieter_cron_expr_next(out &C.vieter_cron_simple_time, ce &C.vieter_cron_expression, ref &C.vieter_cron_simple_time)
+
+fn C.vieter_cron_expr_next_from_now(out &C.vieter_cron_simple_time, ce &C.vieter_cron_expression)
+
+fn C.vieter_cron_expr_parse(out &C.vieter_cron_expression, s &char) ParseError

src/cron/expression.v

@@ -0,0 +1,73 @@
+module cron
+
+import time
+
+// free the memory associated with the Expression.
+[unsafe]
+pub fn (ce &Expression) free() {
+	C.vieter_cron_expr_free(ce)
+}
+
+// parse_expression parses a string into an Expression.
+pub fn parse_expression(exp string) !&Expression {
+	out := C.vieter_cron_expr_init()
+	res := C.vieter_cron_expr_parse(out, exp.str)
+
+	if res != .ok {
+		return error(res.str())
+	}
+
+	return out
+}
+
+// next calculates the next occurence of the cron schedule, given a reference
+// point.
+pub fn (ce &Expression) next(ref time.Time) time.Time {
+	st := SimpleTime{
+		year: ref.year
+		month: ref.month
+		day: ref.day
+		hour: ref.hour
+		minute: ref.minute
+	}
+
+	out := SimpleTime{}
+	C.vieter_cron_expr_next(&out, ce, &st)
+
+	return time.new_time(time.Time{
+		year: out.year
+		month: out.month
+		day: out.day
+		hour: out.hour
+		minute: out.minute
+	})
+}
+
+// next_from_now calculates the next occurence of the cron schedule with the
+// current time as reference.
+pub fn (ce &Expression) next_from_now() time.Time {
+	out := SimpleTime{}
+	C.vieter_cron_expr_next_from_now(&out, ce)
+
+	return time.new_time(time.Time{
+		year: out.year
+		month: out.month
+		day: out.day
+		hour: out.hour
+		minute: out.minute
+	})
+}
+
+// next_n returns the n next occurences of the expression, given a starting
+// time.
+pub fn (ce &Expression) next_n(ref time.Time, n int) []time.Time {
+	mut times := []time.Time{cap: n}
+
+	times << ce.next(ref)
+
+	for i in 1 .. n {
+		times << ce.next(times[i - 1])
+	}
+
+	return times
+}

src/cron/expression/expression.v

@@ -1,275 +0,0 @@
-module expression
-
-import time
-
-pub struct CronExpression {
-	minutes []int
-	hours   []int
-	days    []int
-	months  []int
-}
-
-// next calculates the earliest time this cron expression is valid. It will
-// always pick a moment in the future, even if ref matches completely up to the
-// minute. This function conciously does not take gap years into account.
-pub fn (ce &CronExpression) next(ref time.Time) ?time.Time {
-	// If the given ref matches the next cron occurence up to the minute, it
-	// will return that value. Because we always want to return a value in the
-	// future, we artifically shift the ref 60 seconds to make sure we always
-	// match in the future. A shift of 60 seconds is enough because the cron
-	// expression does not allow for accuracy smaller than one minute.
-	sref := ref
-
-	// For all of these values, the rule is the following: if their value is
-	// the length of their respective array in the CronExpression object, that
-	// means we've looped back around. This means that the "bigger" value has
-	// to be incremented by one. For example, if the minutes have looped
-	// around, that means that the hour has to be incremented as well.
-	mut minute_index := 0
-	mut hour_index := 0
-	mut day_index := 0
-	mut month_index := 0
-
-	// This chain is the same logic multiple times, namely that if a "bigger"
-	// value loops around, then the smaller value will always reset as well.
-	// For example, if we're going to a new day, the hour & minute will always
-	// be their smallest value again.
-	for month_index < ce.months.len && sref.month > ce.months[month_index] {
-		month_index++
-	}
-
-	if month_index < ce.months.len && sref.month == ce.months[month_index] {
-		for day_index < ce.days.len && sref.day > ce.days[day_index] {
-			day_index++
-		}
-
-		if day_index < ce.days.len && ce.days[day_index] == sref.day {
-			for hour_index < ce.hours.len && sref.hour > ce.hours[hour_index] {
-				hour_index++
-			}
-
-			if hour_index < ce.hours.len && ce.hours[hour_index] == sref.hour {
-				// Minute is the only value where we explicitely make sure we
-				// can't match sref's value exactly. This is to ensure we only
-				// return values in the future.
-				for minute_index < ce.minutes.len && sref.minute >= ce.minutes[minute_index] {
-					minute_index++
-				}
-			}
-		}
-	}
-
-	// Here, we increment the "bigger" values by one if the smaller ones loop
-	// around. The order is important, as it allows a sort-of waterfall effect
-	// to occur which updates all values if required.
-	if minute_index == ce.minutes.len && hour_index < ce.hours.len {
-		hour_index += 1
-	}
-
-	if hour_index == ce.hours.len && day_index < ce.days.len {
-		day_index += 1
-	}
-
-	if day_index == ce.days.len && month_index < ce.months.len {
-		month_index += 1
-	}
-
-	mut minute := ce.minutes[minute_index % ce.minutes.len]
-	mut hour := ce.hours[hour_index % ce.hours.len]
-	mut day := ce.days[day_index % ce.days.len]
-
-	// Sometimes, we end up with a day that does not exist within the selected
-	// month, e.g. day 30 in February. When this occurs, we reset day back to
-	// the smallest value & loop over to the next month that does have this
-	// day.
-	if day > time.month_days[ce.months[month_index % ce.months.len] - 1] {
-		day = ce.days[0]
-		month_index += 1
-
-		for day > time.month_days[ce.months[month_index & ce.months.len] - 1] {
-			month_index += 1
-
-			// If for whatever reason the day value ends up being something
-			// that can't be scheduled in any month, we have to make sure we
-			// don't create an infinite loop.
-			if month_index == 2 * ce.months.len {
-				return error('No schedulable moment.')
-			}
-		}
-	}
-
-	month := ce.months[month_index % ce.months.len]
-	mut year := sref.year
-
-	// If the month loops over, we need to increment the year.
-	if month_index >= ce.months.len {
-		year++
-	}
-
-	return time.new_time(time.Time{
-		year: year
-		month: month
-		day: day
-		minute: minute
-		hour: hour
-	})
-}
-
-// next_from_now returns the result of ce.next(ref) where ref is the result of
-// time.now().
-pub fn (ce &CronExpression) next_from_now() ?time.Time {
-	return ce.next(time.now())
-}
-
-// next_n returns the n next occurences of the expression, given a starting
-// time.
-pub fn (ce &CronExpression) next_n(ref time.Time, n int) ?[]time.Time {
-	mut times := []time.Time{cap: n}
-
-	times << ce.next(ref)?
-
-	for i in 1 .. n {
-		times << ce.next(times[i - 1])?
-	}
-
-	return times
-}
-
-// parse_range parses a given string into a range of sorted integers, if
-// possible.
-fn parse_range(s string, min int, max int, mut bitv []bool) ? {
-	mut start := min
-	mut end := max
-	mut interval := 1
-
-	exps := s.split('/')
-
-	if exps.len > 2 {
-		return error('Invalid expression.')
-	}
-
-	if exps[0] != '*' {
-		dash_parts := exps[0].split('-')
-
-		if dash_parts.len > 2 {
-			return error('Invalid expression.')
-		}
-
-		start = dash_parts[0].int()
-
-		// The builtin parsing functions return zero if the string can't be
-		// parsed into a number, so we have to explicitely check whether they
-		// actually entered zero or if it's an invalid number.
-		if start == 0 && dash_parts[0] != '0' {
-			return error('Invalid number.')
-		}
-
-		// Check whether the start value is out of range
-		if start < min || start > max {
-			return error('Out of range.')
-		}
-
-		if dash_parts.len == 2 {
-			end = dash_parts[1].int()
-
-			if end == 0 && dash_parts[1] != '0' {
-				return error('Invalid number.')
-			}
-
-			if end < start || end > max {
-				return error('Out of range.')
-			}
-		}
-	}
-
-	if exps.len > 1 {
-		interval = exps[1].int()
-
-		// interval being zero is always invalid, but we want to check why
-		// it's invalid for better error messages.
-		if interval == 0 {
-			if exps[1] != '0' {
-				return error('Invalid number.')
-			} else {
-				return error('Step size zero not allowed.')
-			}
-		}
-
-		if interval > max - min {
-			return error('Step size too large.')
-		}
-	}
-	// Here, s solely consists of a number, so that's the only value we
-	// should return.
-	else if exps[0] != '*' && !exps[0].contains('-') {
-		bitv[start - min] = true
-		return
-	}
-
-	for start <= end {
-		bitv[start - min] = true
-		start += interval
-	}
-}
-
-// bitv_to_ints converts a bit vector into an array containing the
-// corresponding values.
-fn bitv_to_ints(bitv []bool, min int) []int {
-	mut out := []int{}
-
-	for i in 0 .. bitv.len {
-		if bitv[i] {
-			out << min + i
-		}
-	}
-
-	return out
-}
-
-// parse_part parses a given part of a cron expression & returns the
-// corresponding array of ints.
-fn parse_part(s string, min int, max int) ?[]int {
-	mut bitv := []bool{len: max - min + 1, init: false}
-
-	for range in s.split(',') {
-		parse_range(range, min, max, mut bitv)?
-	}
-
-	return bitv_to_ints(bitv, min)
-}
-
-// parse_expression parses an entire cron expression string into a
-// CronExpression object, if possible.
-pub fn parse_expression(exp string) ?CronExpression {
-	// The filter allows for multiple spaces between parts
-	mut parts := exp.split(' ').filter(it != '')
-
-	if parts.len < 2 || parts.len > 4 {
-		return error('Expression must contain between 2 and 4 space-separated parts.')
-	}
-
-	// For ease of use, we allow the user to only specify as many parts as they
-	// need.
-	for parts.len < 4 {
-		parts << '*'
-	}
-
-	mut part_results := [][]int{}
-
-	mins := [0, 0, 1, 1]
-	maxs := [59, 23, 31, 12]
-
-	// This for loop allows us to more clearly propagate the error to the user.
-	for i, min in mins {
-		part_results << parse_part(parts[i], min, maxs[i]) or {
-			return error('An error occurred with part $i: $err.msg()')
-		}
-	}
-
-	return CronExpression{
-		minutes: part_results[0]
-		hours: part_results[1]
-		days: part_results[2]
-		months: part_results[3]
-	}
-}

src/cron/expression/expression_parse_test.v

@@ -1,98 +0,0 @@
-module expression
-
-// parse_range_error returns the returned error message. If the result is '',
-// that means the function didn't error.
-fn parse_range_error(s string, min int, max int) string {
-	mut bitv := []bool{len: max - min + 1, init: false}
-
-	parse_range(s, min, max, mut bitv) or { return err.msg }
-
-	return ''
-}
-
-// =====parse_range=====
-fn test_range_star_range() ? {
-	mut bitv := []bool{len: 6, init: false}
-	parse_range('*', 0, 5, mut bitv)?
-
-	assert bitv == [true, true, true, true, true, true]
-}
-
-fn test_range_number() ? {
-	mut bitv := []bool{len: 6, init: false}
-	parse_range('4', 0, 5, mut bitv)?
-
-	assert bitv_to_ints(bitv, 0) == [4]
-}
-
-fn test_range_number_too_large() ? {
-	assert parse_range_error('10', 0, 6) == 'Out of range.'
-}
-
-fn test_range_number_too_small() ? {
-	assert parse_range_error('0', 2, 6) == 'Out of range.'
-}
-
-fn test_range_number_invalid() ? {
-	assert parse_range_error('x', 0, 6) == 'Invalid number.'
-}
-
-fn test_range_step_star_1() ? {
-	mut bitv := []bool{len: 21, init: false}
-	parse_range('*/4', 0, 20, mut bitv)?
-
-	assert bitv_to_ints(bitv, 0) == [0, 4, 8, 12, 16, 20]
-}
-
-fn test_range_step_star_2() ? {
-	mut bitv := []bool{len: 8, init: false}
-	parse_range('*/3', 1, 8, mut bitv)?
-
-	assert bitv_to_ints(bitv, 1) == [1, 4, 7]
-}
-
-fn test_range_step_star_too_large() ? {
-	assert parse_range_error('*/21', 0, 20) == 'Step size too large.'
-}
-
-fn test_range_step_zero() ? {
-	assert parse_range_error('*/0', 0, 20) == 'Step size zero not allowed.'
-}
-
-fn test_range_step_number() ? {
-	mut bitv := []bool{len: 21, init: false}
-	parse_range('5/4', 2, 22, mut bitv)?
-
-	assert bitv_to_ints(bitv, 2) == [5, 9, 13, 17, 21]
-}
-
-fn test_range_step_number_too_large() ? {
-	assert parse_range_error('10/4', 0, 5) == 'Out of range.'
-}
-
-fn test_range_step_number_too_small() ? {
-	assert parse_range_error('2/4', 5, 10) == 'Out of range.'
-}
-
-fn test_range_dash() ? {
-	mut bitv := []bool{len: 10, init: false}
-	parse_range('4-8', 0, 9, mut bitv)?
-
-	assert bitv_to_ints(bitv, 0) == [4, 5, 6, 7, 8]
-}
-
-fn test_range_dash_step() ? {
-	mut bitv := []bool{len: 10, init: false}
-	parse_range('4-8/2', 0, 9, mut bitv)?
-
-	assert bitv_to_ints(bitv, 0) == [4, 6, 8]
-}
-
-// =====parse_part=====
-fn test_part_single() ? {
-	assert parse_part('*', 0, 5)? == [0, 1, 2, 3, 4, 5]
-}
-
-fn test_part_multiple() ? {
-	assert parse_part('*/2,2/3', 1, 8)? == [1, 2, 3, 5, 7, 8]
-}

src/cron/expression/expression_test.v

@@ -1,34 +0,0 @@
-module expression
-
-import time { parse }
-
-fn util_test_time(exp string, t1_str string, t2_str string) ? {
-	ce := parse_expression(exp)?
-	t1 := parse(t1_str)?
-	t2 := parse(t2_str)?
-
-	t3 := ce.next(t1)?
-
-	assert t2.year == t3.year
-	assert t2.month == t3.month
-	assert t2.day == t3.day
-	assert t2.hour == t3.hour
-	assert t2.minute == t3.minute
-}
-
-fn test_next_simple() ? {
-	// Very simple
-	util_test_time('0 3', '2002-01-01 00:00:00', '2002-01-01 03:00:00')?
-
-	// Overlap to next day
-	util_test_time('0 3', '2002-01-01 03:00:00', '2002-01-02 03:00:00')?
-	util_test_time('0 3', '2002-01-01 04:00:00', '2002-01-02 03:00:00')?
-
-	util_test_time('0 3/4', '2002-01-01 04:00:00', '2002-01-01 07:00:00')?
-
-	// Overlap to next month
-	util_test_time('0 3', '2002-11-31 04:00:00', '2002-12-01 03:00:00')?
-
-	// Overlap to next year
-	util_test_time('0 3', '2002-12-31 04:00:00', '2003-01-01 03:00:00')?
-}

src/cron/expression_test.v

@@ -0,0 +1,35 @@
+module cron
+
+import time { parse }
+
+fn util_test_time(exp string, t1_str string, t2_str string) ! {
+	ce := parse_expression(exp)!
+	t1 := parse(t1_str)!
+	t2 := parse(t2_str)!
+
+	t3 := ce.next(t1)
+
+	assert t2.year == t3.year
+	assert t2.month == t3.month
+	assert t2.day == t3.day
+	assert t2.hour == t3.hour
+	assert t2.minute == t3.minute
+}
+
+fn test_next_simple() ! {
+	// Very simple
+	// util_test_time('0 3', '2002-01-01 00:00:00', '2002-01-01 03:00:00')!
+
+	// Overlap to next day
+	mut exp := '0    3         '
+	util_test_time(exp, '2002-01-01 03:00:00', '2002-01-02 03:00:00')!
+	util_test_time(exp, '2002-01-01 04:00:00', '2002-01-02 03:00:00')!
+
+	util_test_time('0 3-7/4,7-19', '2002-01-01 04:00:00', '2002-01-01 07:00:00')!
+
+	//// Overlap to next month
+	util_test_time('0 3', '2002-11-31 04:00:00', '2002-12-01 03:00:00')!
+
+	//// Overlap to next year
+	util_test_time('0 3', '2002-12-31 04:00:00', '2003-01-01 03:00:00')!
+}

src/cron/parse_test.v

@@ -0,0 +1,42 @@
+module cron
+
+fn test_not_allowed() {
+	illegal_expressions := [
+		'4 *-7',
+		'4 *-7/4',
+		'4 7/*',
+		'0 0 30 2',
+		'0 /5',
+		'0  ',
+		'0',
+		'      0',
+		'       0      ',
+		'1 2 3 4~9',
+		'1 1-3-5',
+		'0 5/2-5',
+		'',
+		'1 1/2/3',
+		'*5 8',
+		'x 8',
+	]
+
+	mut res := false
+
+	for exp in illegal_expressions {
+		res = false
+		parse_expression(exp) or { res = true }
+		assert res, "'${exp}' should produce an error"
+	}
+}
+
+fn test_auto_extend() ! {
+	ce1 := parse_expression('5 5')!
+	ce2 := parse_expression('5 5 *')!
+	ce3 := parse_expression('5 5 * *')!
+
+	assert ce1 == ce2 && ce2 == ce3
+}
+
+fn test_four() {
+	parse_expression('0 1 2 3 ') or { assert false }
+}

src/db/git.v

@@ -1,99 +0,0 @@
-module db
-
-import models { GitRepo, GitRepoArch, GitRepoFilter }
-
-// get_git_repos returns all GitRepo's in the database.
-pub fn (db &VieterDb) get_git_repos(filter GitRepoFilter) []GitRepo {
-	// This seems to currently be blocked by a bug in the ORM, I'll have to ask
-	// around.
-	if filter.repo != '' {
-		res := sql db.conn {
-			select from GitRepo where repo == filter.repo order by id limit filter.limit offset filter.offset
-		}
-
-		return res
-	}
-
-	res := sql db.conn {
-		select from GitRepo order by id limit filter.limit offset filter.offset
-	}
-
-	return res
-}
-
-// get_git_repo tries to return a specific GitRepo.
-pub fn (db &VieterDb) get_git_repo(repo_id int) ?GitRepo {
-	res := sql db.conn {
-		select from GitRepo where id == repo_id
-	}
-
-	// If a select statement fails, it returns a zeroed object. By
-	// checking one of the required fields, we can see whether the query
-	// returned a result or not.
-	if res.id == 0 {
-		return none
-	}
-
-	return res
-}
-
-// add_git_repo inserts the given GitRepo into the database.
-pub fn (db &VieterDb) add_git_repo(repo GitRepo) {
-	sql db.conn {
-		insert repo into GitRepo
-	}
-}
-
-// delete_git_repo deletes the repo with the given ID from the database.
-pub fn (db &VieterDb) delete_git_repo(repo_id int) {
-	sql db.conn {
-		delete from GitRepo where id == repo_id
-		delete from GitRepoArch where repo_id == repo_id
-	}
-}
-
-// update_git_repo updates any non-array values for a given GitRepo.
-pub fn (db &VieterDb) update_git_repo(repo_id int, params map[string]string) {
-	mut values := []string{}
-
-	// TODO does this allow for SQL injection?
-	$for field in GitRepo.fields {
-		if field.name in params {
-			// Any fields that are array types require their own update method
-			$if field.typ is string {
-				values << "$field.name = '${params[field.name]}'"
-			}
-		}
-	}
-	values_str := values.join(', ')
-	// I think this is actual SQL & not the ORM language
-	query := 'update GitRepo set $values_str where id == $repo_id'
-
-	db.conn.exec_none(query)
-}
-
-// update_git_repo_archs updates a given GitRepo's arch value.
-pub fn (db &VieterDb) update_git_repo_archs(repo_id int, archs []GitRepoArch) {
-	archs_with_id := archs.map(GitRepoArch{
-		...it
-		repo_id: repo_id
-	})
-
-	sql db.conn {
-		delete from GitRepoArch where repo_id == repo_id
-	}
-
-	for arch in archs_with_id {
-		sql db.conn {
-			insert arch into GitRepoArch
-		}
-	}
-}
-
-// git_repo_exists is a utility function that checks whether a repo with the
-// given id exists.
-pub fn (db &VieterDb) git_repo_exists(repo_id int) bool {
-	db.get_git_repo(repo_id) or { return false }
-
-	return true
-}

src/dbms/dbms.v

@@ -1,9 +1,9 @@
-module db
+module dbms
 
-import sqlite
+import db.sqlite
 import time
 
-struct VieterDb {
+pub struct VieterDb {
 	conn sqlite.DB
 }
 
@@ -13,13 +13,25 @@ struct MigrationVersion {
 }
 
 const (
-	migrations_up   = [$embed_file('migrations/001-initial/up.sql')]
-	migrations_down = [$embed_file('migrations/001-initial/down.sql')]
+	migrations_up   = [
+		$embed_file('migrations/001-initial/up.sql'),
+		$embed_file('migrations/002-rename-to-targets/up.sql'),
+		$embed_file('migrations/003-target-url-type/up.sql'),
+		$embed_file('migrations/004-nullable-branch/up.sql'),
+		$embed_file('migrations/005-repo-path/up.sql'),
+	]
+	migrations_down = [
+		$embed_file('migrations/001-initial/down.sql'),
+		$embed_file('migrations/002-rename-to-targets/down.sql'),
+		$embed_file('migrations/003-target-url-type/down.sql'),
+		$embed_file('migrations/004-nullable-branch/down.sql'),
+		$embed_file('migrations/005-repo-path/down.sql'),
+	]
 )
 
 // init initializes a database & adds the correct tables.
-pub fn init(db_path string) ?VieterDb {
-	conn := sqlite.connect(db_path)?
+pub fn init(db_path string) !VieterDb {
+	conn := sqlite.connect(db_path)!
 
 	sql conn {
 		create table MigrationVersion
@@ -37,13 +49,13 @@ pub fn init(db_path string) ?VieterDb {
 	}
 
 	// Apply each migration in order
-	for i in cur_version.version .. db.migrations_up.len {
-		migration := db.migrations_up[i].to_string()
+	for i in cur_version.version .. dbms.migrations_up.len {
+		migration := dbms.migrations_up[i].to_string()
 
 		version_num := i + 1
 
 		// vfmt does not like these dots
-		println('Applying migration $version_num' + '...')
+		println('Applying migration ${version_num}' + '...')
 
 		// The sqlite library seems to not like it when multiple statements are
 		// passed in a single exec. Therefore, we split them & run them all
@@ -52,7 +64,7 @@ pub fn init(db_path string) ?VieterDb {
 			res := conn.exec_none(part)
 
 			if res != sqlite.sqlite_done {
-				return error('An error occurred while applying migration $version_num')
+				return error('An error occurred while applying migration ${version_num}: SQLite error code ${res}')
 			}
 		}
 
@@ -68,9 +80,9 @@ pub fn init(db_path string) ?VieterDb {
 	}
 }
 
-// row_into<T> converts an sqlite.Row into a given type T by parsing each field
+// row_into[T] converts an sqlite.Row into a given type T by parsing each field
 // from a string according to its type.
-pub fn row_into<T>(row sqlite.Row) T {
+pub fn row_into[T](row sqlite.Row) T {
 	mut i := 0
 	mut out := T{}
 

src/dbms/logs.v

@@ -1,4 +1,4 @@
-module db
+module dbms
 
 import models { BuildLog, BuildLogFilter }
 import time
@@ -7,21 +7,21 @@ import time
 pub fn (db &VieterDb) get_build_logs(filter BuildLogFilter) []BuildLog {
 	mut where_parts := []string{}
 
-	if filter.repo != 0 {
-		where_parts << 'repo_id == $filter.repo'
+	if filter.target != 0 {
+		where_parts << 'target_id == ${filter.target}'
 	}
 
 	if filter.before != time.Time{} {
-		where_parts << 'start_time < $filter.before.unix_time()'
+		where_parts << 'start_time < ${filter.before.unix_time()}'
 	}
 
 	if filter.after != time.Time{} {
-		where_parts << 'start_time > $filter.after.unix_time()'
+		where_parts << 'start_time > ${filter.after.unix_time()}'
 	}
 
 	// NOTE: possible SQL injection
 	if filter.arch != '' {
-		where_parts << "arch == '$filter.arch'"
+		where_parts << "arch == '${filter.arch}'"
 	}
 
 	mut parts := []string{}
@@ -30,36 +30,36 @@ pub fn (db &VieterDb) get_build_logs(filter BuildLogFilter) []BuildLog {
 		if exp[0] == `!` {
 			code := exp[1..].int()
 
-			parts << 'exit_code != $code'
+			parts << 'exit_code != ${code}'
 		} else {
 			code := exp.int()
 
-			parts << 'exit_code == $code'
+			parts << 'exit_code == ${code}'
 		}
 	}
 
 	if parts.len > 0 {
-		where_parts << parts.map('($it)').join(' or ')
+		where_parts << parts.map('(${it})').join(' or ')
 	}
 
 	mut where_str := ''
 
 	if where_parts.len > 0 {
-		where_str = 'where ' + where_parts.map('($it)').join(' and ')
+		where_str = 'where ' + where_parts.map('(${it})').join(' and ')
 	}
 
-	query := 'select * from BuildLog $where_str limit $filter.limit offset $filter.offset'
+	query := 'select * from BuildLog ${where_str} limit ${filter.limit} offset ${filter.offset}'
 	rows, _ := db.conn.exec(query)
-	res := rows.map(row_into<BuildLog>(it))
+	res := rows.map(row_into[BuildLog](it))
 
 	return res
 }
 
-// get_build_logs_for_repo returns all BuildLog's in the database for a given
-// repo.
-pub fn (db &VieterDb) get_build_logs_for_repo(repo_id int) []BuildLog {
+// get_build_logs_for_target returns all BuildLog's in the database for a given
+// target.
+pub fn (db &VieterDb) get_build_logs_for_target(target_id int) []BuildLog {
 	res := sql db.conn {
-		select from BuildLog where repo_id == repo_id order by id
+		select from BuildLog where target_id == target_id order by id
 	}
 
 	return res
@@ -79,10 +79,16 @@ pub fn (db &VieterDb) get_build_log(id int) ?BuildLog {
 }
 
 // add_build_log inserts the given BuildLog into the database.
-pub fn (db &VieterDb) add_build_log(log BuildLog) {
+pub fn (db &VieterDb) add_build_log(log BuildLog) int {
 	sql db.conn {
 		insert log into BuildLog
 	}
+
+	// Here, this does work because a log doesn't contain any foreign keys,
+	// meaning the ORM only has to do a single add
+	inserted_id := db.conn.last_id() as int
+
+	return inserted_id
 }
 
 // delete_build_log delete the BuildLog with the given ID from the database.

src/dbms/migrations/002-rename-to-targets/down.sql

@@ -0,0 +1,5 @@
+ALTER TABLE Target RENAME TO GitRepo;
+ALTER TABLE TargetArch RENAME TO GitRepoArch;
+
+ALTER TABLE GitRepoArch RENAME COLUMN target_id TO repo_id;
+ALTER TABLE BuildLog RENAME COLUMN target_id TO repo_id;

src/dbms/migrations/002-rename-to-targets/up.sql

@@ -0,0 +1,5 @@
+ALTER TABLE GitRepo RENAME TO Target;
+ALTER TABLE GitRepoArch RENAME TO TargetArch;
+
+ALTER TABLE TargetArch RENAME COLUMN repo_id TO target_id;
+ALTER TABLE BuildLog RENAME COLUMN repo_id TO target_id;

src/dbms/migrations/003-target-url-type/down.sql

@@ -0,0 +1,4 @@
+-- I'm not sure whether I should remove any non-git targets here. Keeping them
+-- will result in invalid targets, but removing them means losing data.
+ALTER TABLE Target DROP COLUMN kind;
+

src/dbms/migrations/003-target-url-type/up.sql

@@ -0,0 +1 @@
+ALTER TABLE Target ADD COLUMN kind TEXT NOT NULL DEFAULT 'git';

src/dbms/migrations/004-nullable-branch/down.sql

@@ -0,0 +1,26 @@
+-- This down won't really work because it'll throw NOT NULL errors, but I'm
+-- just putting it here for future reference (still not sure whether I'm even
+    -- gonna use these)
+PRAGMA foreign_keys=off;
+
+BEGIN TRANSACTION;
+
+ALTER TABLE Target RENAME TO _Target_old;
+
+CREATE TABLE Target (
+    id INTEGER PRIMARY KEY,
+    url TEXT NOT NULL,
+    branch TEXT NOT NULL,
+    repo TEXT NOT NULL,
+    schedule TEXT,
+    kind TEXT NOT NULL DEFAULT 'git'
+);
+
+INSERT INTO Target (id, url, branch, repo, schedule, kind)
+    SELECT id, url, branch, repo, schedule, kind FROM _Target_old;
+
+DROP TABLE _Target_old;
+
+COMMIT;
+
+PRAGMA foreign_keys=on;

src/dbms/migrations/004-nullable-branch/up.sql

@@ -0,0 +1,23 @@
+PRAGMA foreign_keys=off;
+
+BEGIN TRANSACTION;
+
+ALTER TABLE Target RENAME TO _Target_old;
+
+CREATE TABLE Target (
+    id INTEGER PRIMARY KEY,
+    url TEXT NOT NULL,
+    branch TEXT,
+    repo TEXT NOT NULL,
+    schedule TEXT,
+    kind TEXT NOT NULL DEFAULT 'git'
+);
+
+INSERT INTO Target (id, url, branch, repo, schedule, kind)
+    SELECT id, url, branch, repo, schedule, kind FROM _Target_old;
+
+DROP TABLE _Target_old;
+
+COMMIT;
+
+PRAGMA foreign_keys=on;

src/dbms/migrations/005-repo-path/down.sql

@@ -0,0 +1 @@
+ALTER TABLE Target DROP COLUMN path;

src/dbms/migrations/005-repo-path/up.sql

@@ -0,0 +1 @@
+ALTER TABLE Target ADD COLUMN path TEXT;

src/dbms/targets.v

@@ -0,0 +1,87 @@
+module dbms
+
+import models { Target, TargetArch }
+
+// get_target tries to return a specific target.
+pub fn (db &VieterDb) get_target(target_id int) ?Target {
+	res := sql db.conn {
+		select from Target where id == target_id
+	}
+
+	// If a select statement fails, it returns a zeroed object. By
+	// checking one of the required fields, we can see whether the query
+	// returned a result or not.
+	if res.id == 0 {
+		return none
+	}
+
+	return res
+}
+
+// add_target inserts the given target into the database.
+pub fn (db &VieterDb) add_target(target Target) int {
+	sql db.conn {
+		insert target into Target
+	}
+
+	// ID of inserted target is the largest id
+	inserted_target := sql db.conn {
+		select from Target order by id desc limit 1
+	}
+
+	return inserted_target.id
+}
+
+// delete_target deletes the target with the given id from the database.
+pub fn (db &VieterDb) delete_target(target_id int) {
+	sql db.conn {
+		delete from Target where id == target_id
+		delete from TargetArch where target_id == target_id
+	}
+}
+
+// update_target updates any non-array values for a given target.
+pub fn (db &VieterDb) update_target(target_id int, params map[string]string) {
+	mut values := []string{}
+
+	// TODO does this allow for SQL injection?
+	$for field in Target.fields {
+		if field.name in params {
+			// Any fields that are array types require their own update method
+			$if field.typ is string {
+				values << "${field.name} = '${params[field.name]}'"
+			}
+		}
+	}
+	values_str := values.join(', ')
+	// I think this is actual SQL & not the ORM language
+	query := 'update Target set ${values_str} where id == ${target_id}'
+
+	db.conn.exec_none(query)
+}
+
+// update_target_archs updates a given target's arch value.
+pub fn (db &VieterDb) update_target_archs(target_id int, archs []TargetArch) {
+	archs_with_id := archs.map(TargetArch{
+		...it
+		target_id: target_id
+	})
+
+	sql db.conn {
+		delete from TargetArch where target_id == target_id
+	}
+
+	for arch in archs_with_id {
+		sql db.conn {
+			insert arch into TargetArch
+		}
+	}
+}
+
+// target_exists is a utility function that checks whether a target with the
+// given id exists.
+pub fn (db &VieterDb) target_exists(target_id int) bool {
+	db.get_target(target_id) or { return false }
+
+	return true
+}

src/dbms/targets_iter.v

@@ -0,0 +1,129 @@
+module dbms
+
+import models { Target, TargetFilter }
+import db.sqlite
+
+// Iterator providing a filtered view into the list of targets currently stored
+// in the database. It replaces functionality usually performed in the database
+// using SQL queries that can't currently be used due to missing stuff in V's
+// ORM.
+pub struct TargetsIterator {
+	conn        sqlite.DB
+	filter      TargetFilter
+	window_size int = 32
+mut:
+	window       []Target
+	window_index u64
+	// Offset in entire list of unfiltered targets
+	offset int
+	// Offset in filtered list of targets
+	filtered_offset u64
+	started         bool
+	done            bool
+}
+
+// targets returns an iterator allowing filtered access to the list of targets.
+pub fn (db &VieterDb) targets(filter TargetFilter) TargetsIterator {
+	window_size := 32
+
+	return TargetsIterator{
+		conn: db.conn
+		filter: filter
+		window: []Target{cap: window_size}
+		window_size: window_size
+	}
+}
+
+// advance_window moves the sliding window over the filtered list of targets
+// until it either reaches the end of the list of targets, or has encountered a
+// non-empty window.
+fn (mut ti TargetsIterator) advance_window() {
+	for {
+		ti.window = sql ti.conn {
+			select from Target order by id limit ti.window_size offset ti.offset
+		}
+		ti.offset += ti.window.len
+
+		if ti.window.len == 0 {
+			ti.done = true
+
+			return
+		}
+
+		if ti.filter.repo != '' {
+			ti.window = ti.window.filter(it.repo == ti.filter.repo)
+		}
+
+		if ti.filter.arch != '' {
+			ti.window = ti.window.filter(it.arch.any(it.value == ti.filter.arch))
+		}
+
+		if ti.filter.query != '' {
+			ti.window = ti.window.filter(it.url.contains(ti.filter.query)
+				|| it.path.contains(ti.filter.query) || it.branch.contains(ti.filter.query))
+		}
+
+		// We break out of the loop once we found a non-empty window
+		if ti.window.len > 0 {
+			break
+		}
+	}
+}
+
+// next returns the next target, if possible.
+pub fn (mut ti TargetsIterator) next() ?Target {
+	if ti.done {
+		return none
+	}
+
+	// The first call to `next` will cause the sliding window to move to where
+	// the requested offset starts
+	if !ti.started {
+		ti.advance_window()
+
+		// Skip all matched targets until the requested offset
+		for !ti.done && ti.filtered_offset + u64(ti.window.len) <= ti.filter.offset {
+			ti.filtered_offset += u64(ti.window.len)
+			ti.advance_window()
+		}
+
+		if ti.done {
+			return none
+		}
+
+		left_inside_window := ti.filter.offset - ti.filtered_offset
+		ti.window_index = left_inside_window
+		ti.filtered_offset += left_inside_window
+
+		ti.started = true
+	}
+
+	return_value := ti.window[ti.window_index]
+
+	ti.window_index++
+	ti.filtered_offset++
+
+	// Next call will be past the requested offset
+	if ti.filter.limit > 0 && ti.filtered_offset == ti.filter.offset + ti.filter.limit {
+		ti.done = true
+	}
+
+	// Ensure the next call has a new valid window
+	if ti.window_index == u64(ti.window.len) {
+		ti.advance_window()
+		ti.window_index = 0
+	}
+
+	return return_value
+}
+
+// collect consumes the entire iterator & returns the result as an array.
+pub fn (mut ti TargetsIterator) collect() []Target {
+	mut out := []Target{}
+
+	for t in ti {
+		out << t
+	}
+
+	return out
+}

src/docker/README.md

@@ -1,3 +0,0 @@
-This module implements part of the Docker Engine API v1.41
-([documentation](https://docs.docker.com/engine/api/v1.41/)) using socket-based
-HTTP communication.

src/docker/containers.v

@@ -1,123 +0,0 @@
-module docker
-
-import json
-import net.urllib
-import time
-import net.http { Method }
-
-struct DockerError {
-	message string
-}
-
-pub struct NewContainer {
-	image      string   [json: Image]
-	entrypoint []string [json: Entrypoint]
-	cmd        []string [json: Cmd]
-	env        []string [json: Env]
-	work_dir   string   [json: WorkingDir]
-	user       string   [json: User]
-}
-
-struct CreatedContainer {
-pub:
-	id       string   [json: Id]
-	warnings []string [json: Warnings]
-}
-
-// create_container creates a new container with the given config.
-pub fn (mut d DockerConn) create_container(c NewContainer) ?CreatedContainer {
-	d.send_request_with_json(Method.post, urllib.parse('/v1.41/containers/create')?, c)?
-	head, res := d.read_response()?
-
-	if head.status_code != 201 {
-		data := json.decode(DockerError, res)?
-
-		return error(data.message)
-	}
-
-	data := json.decode(CreatedContainer, res)?
-
-	return data
-}
-
-// start_container starts the container with the given id.
-pub fn (mut d DockerConn) start_container(id string) ? {
-	d.send_request(Method.post, urllib.parse('/v1.41/containers/$id/start')?)?
-	head, body := d.read_response()?
-
-	if head.status_code != 204 {
-		data := json.decode(DockerError, body)?
-
-		return error(data.message)
-	}
-}
-
-struct ContainerInspect {
-pub mut:
-	state ContainerState [json: State]
-}
-
-struct ContainerState {
-pub:
-	running   bool   [json: Running]
-	status    string [json: Status]
-	exit_code int    [json: ExitCode]
-	// These use a rather specific format so they have to be parsed later
-	start_time_str string [json: StartedAt]
-	end_time_str   string [json: FinishedAt]
-pub mut:
-	start_time time.Time [skip]
-	end_time   time.Time [skip]
-}
-
-// inspect_container returns detailed information for a given container.
-pub fn (mut d DockerConn) inspect_container(id string) ?ContainerInspect {
-	d.send_request(Method.get, urllib.parse('/v1.41/containers/$id/json')?)?
-	head, body := d.read_response()?
-
-	if head.status_code != 200 {
-		data := json.decode(DockerError, body)?
-
-		return error(data.message)
-	}
-
-	mut data := json.decode(ContainerInspect, body)?
-
-	// The Docker engine API *should* always return UTC time.
-	data.state.start_time = time.parse_rfc3339(data.state.start_time_str)?
-
-	if data.state.status == 'exited' {
-		data.state.end_time = time.parse_rfc3339(data.state.end_time_str)?
-	}
-
-	return data
-}
-
-// remove_container removes the container with the given id.
-pub fn (mut d DockerConn) remove_container(id string) ? {
-	d.send_request(Method.delete, urllib.parse('/v1.41/containers/$id')?)?
-	head, body := d.read_response()?
-
-	if head.status_code != 204 {
-		data := json.decode(DockerError, body)?
-
-		return error(data.message)
-	}
-}
-
-// get_container_logs returns a reader object allowing access to the
-// container's logs.
-pub fn (mut d DockerConn) get_container_logs(id string) ?&StreamFormatReader {
-	d.send_request(Method.get, urllib.parse('/v1.41/containers/$id/logs?stdout=true&stderr=true')?)?
-	head := d.read_response_head()?
-
-	if head.status_code != 200 {
-		content_length := head.header.get(http.CommonHeader.content_length)?.int()
-		body := d.read_response_body(content_length)?
-		data := json.decode(DockerError, body)?
-
-		return error(data.message)
-	}
-
-	return d.get_stream_format_reader()
-}

src/docker/docker.v

@@ -1,137 +0,0 @@
-module docker
-
-import net.unix
-import io
-import net.http
-import strings
-import net.urllib
-import json
-import util
-
-const (
-	socket               = '/var/run/docker.sock'
-	buf_len              = 10 * 1024
-	http_separator       = [u8(`\r`), `\n`, `\r`, `\n`]
-	http_chunk_separator = [u8(`\r`), `\n`]
-)
-
-pub struct DockerConn {
-mut:
-	socket &unix.StreamConn
-	reader &io.BufferedReader
-}
-
-// new_conn creates a new connection to the Docker daemon.
-pub fn new_conn() ?&DockerConn {
-	s := unix.connect_stream(docker.socket)?
-
-	d := &DockerConn{
-		socket: s
-		reader: io.new_buffered_reader(reader: s)
-	}
-
-	return d
-}
-
-// close closes the underlying socket connection.
-pub fn (mut d DockerConn) close() ? {
-	d.socket.close()?
-}
-
-// send_request sends an HTTP request without body.
-pub fn (mut d DockerConn) send_request(method http.Method, url urllib.URL) ? {
-	req := '$method $url.request_uri() HTTP/1.1\nHost: localhost\n\n'
-
-	d.socket.write_string(req)?
-
-	// When starting a new request, the reader needs to be reset.
-	d.reader = io.new_buffered_reader(reader: d.socket)
-}
-
-// send_request_with_body sends an HTTP request with the given body.
-pub fn (mut d DockerConn) send_request_with_body(method http.Method, url urllib.URL, content_type string, body string) ? {
-	req := '$method $url.request_uri() HTTP/1.1\nHost: localhost\nContent-Type: $content_type\nContent-Length: $body.len\n\n$body\n\n'
-
-	d.socket.write_string(req)?
-
-	// When starting a new request, the reader needs to be reset.
-	d.reader = io.new_buffered_reader(reader: d.socket)
-}
-
-// send_request_with_json<T> is a convenience wrapper around
-// send_request_with_body that encodes the input as JSON.
-pub fn (mut d DockerConn) send_request_with_json<T>(method http.Method, url urllib.URL, data &T) ? {
-	body := json.encode(data)
-
-	return d.send_request_with_body(method, url, 'application/json', body)
-}
-
-// read_response_head consumes the socket's contents until it encounters
-// '\r\n\r\n', after which it parses the response as an HTTP response.
-// Importantly, this function never consumes the reader past the HTTP
-// separator, so the body can be read fully later on.
-pub fn (mut d DockerConn) read_response_head() ?http.Response {
-	mut res := []u8{}
-
-	util.read_until_separator(mut d.reader, mut res, docker.http_separator)?
-
-	return http.parse_response(res.bytestr())
-}
-
-// read_response_body reads `length` bytes from the stream. It can be used when
-// the response encoding isn't chunked to fully read it.
-pub fn (mut d DockerConn) read_response_body(length int) ?string {
-	if length == 0 {
-		return ''
-	}
-
-	mut buf := []u8{len: docker.buf_len}
-	mut c := 0
-	mut builder := strings.new_builder(docker.buf_len)
-
-	for builder.len < length {
-		c = d.reader.read(mut buf) or { break }
-
-		builder.write(buf[..c])?
-	}
-
-	return builder.str()
-}
-
-// read_response is a convenience function which always consumes the entire
-// response & returns it. It should only be used when we're certain that the
-// result isn't too large.
-pub fn (mut d DockerConn) read_response() ?(http.Response, string) {
-	head := d.read_response_head()?
-
-	if head.header.get(http.CommonHeader.transfer_encoding) or { '' } == 'chunked' {
-		mut builder := strings.new_builder(1024)
-		mut body := d.get_chunked_response_reader()
-
-		util.reader_to_writer(mut body, mut builder)?
-
-		return head, builder.str()
-	}
-
-	content_length := head.header.get(http.CommonHeader.content_length)?.int()
-	res := d.read_response_body(content_length)?
-
-	return head, res
-}
-
-// get_chunked_response_reader returns a ChunkedResponseReader using the socket
-// as reader.
-pub fn (mut d DockerConn) get_chunked_response_reader() &ChunkedResponseReader {
-	r := new_chunked_response_reader(d.reader)
-
-	return r
-}
-
-// get_stream_format_reader returns a StreamFormatReader using the socket as
-// reader.
-pub fn (mut d DockerConn) get_stream_format_reader() &StreamFormatReader {
-	r := new_chunked_response_reader(d.reader)
-	r2 := new_stream_format_reader(r)
-
-	return r2
-}

src/docker/images.v

@@ -1,61 +0,0 @@
-module docker
-
-import net.http { Method }
-import net.urllib
-import json
-
-struct Image {
-pub:
-	id string [json: Id]
-}
-
-// pull_image pulls the given image:tag.
-pub fn (mut d DockerConn) pull_image(image string, tag string) ? {
-	d.send_request(Method.post, urllib.parse('/v1.41/images/create?fromImage=$image&tag=$tag')?)?
-	head := d.read_response_head()?
-
-	if head.status_code != 200 {
-		content_length := head.header.get(http.CommonHeader.content_length)?.int()
-		body := d.read_response_body(content_length)?
-		data := json.decode(DockerError, body)?
-
-		return error(data.message)
-	}
-
-	// Keep reading the body until the pull has completed
-	mut body := d.get_chunked_response_reader()
-
-	mut buf := []u8{len: 1024}
-
-	for {
-		body.read(mut buf) or { break }
-	}
-}
-
-// create_image_from_container creates a new image from a container.
-pub fn (mut d DockerConn) create_image_from_container(id string, repo string, tag string) ?Image {
-	d.send_request(Method.post, urllib.parse('/v1.41/commit?container=$id&repo=$repo&tag=$tag')?)?
-	head, body := d.read_response()?
-
-	if head.status_code != 201 {
-		data := json.decode(DockerError, body)?
-
-		return error(data.message)
-	}
-
-	data := json.decode(Image, body)?
-
-	return data
-}
-
-// remove_image removes the image with the given id.
-pub fn (mut d DockerConn) remove_image(id string) ? {
-	d.send_request(Method.delete, urllib.parse('/v1.41/images/$id')?)?
-	head, body := d.read_response()?
-
-	if head.status_code != 200 {
-		data := json.decode(DockerError, body)?
-
-		return error(data.message)
-	}
-}

src/docker/stream.v

@@ -1,135 +0,0 @@
-module docker
-
-import io
-import util
-import encoding.binary
-import encoding.hex
-
-// ChunkedResponseReader parses an underlying HTTP chunked response, exposing
-// it as if it was a continuous stream of data.
-struct ChunkedResponseReader {
-mut:
-	reader              io.BufferedReader
-	bytes_left_in_chunk u64
-	started             bool
-}
-
-// new_chunked_response_reader creates a new ChunkedResponseReader on the heap
-// with the provided reader.
-pub fn new_chunked_response_reader(reader io.BufferedReader) &ChunkedResponseReader {
-	r := &ChunkedResponseReader{
-		reader: reader
-	}
-
-	return r
-}
-
-// read satisfies the io.Reader interface.
-pub fn (mut r ChunkedResponseReader) read(mut buf []u8) ?int {
-	if r.bytes_left_in_chunk == 0 {
-		// An io.BufferedReader always returns none if its stream has
-		// ended.
-		r.bytes_left_in_chunk = r.read_chunk_size()?
-	}
-
-	mut c := 0
-
-	// Make sure we don't read more than we can safely read. This is to avoid
-	// the underlying reader from becoming out of sync with our parsing:
-	if buf.len > r.bytes_left_in_chunk {
-		c = r.reader.read(mut buf[..r.bytes_left_in_chunk])?
-	} else {
-		c = r.reader.read(mut buf)?
-	}
-
-	r.bytes_left_in_chunk -= u64(c)
-
-	return c
-}
-
-// read_chunk_size advances the reader & reads the size of the next HTTP chunk.
-// This function should only be called if the previous chunk has been
-// completely consumed.
-fn (mut r ChunkedResponseReader) read_chunk_size() ?u64 {
-	if r.started {
-		mut buf := []u8{len: 2}
-
-		// Each chunk ends with a `\r\n` which we want to skip first
-		r.reader.read(mut buf)?
-	}
-
-	r.started = true
-
-	mut res := []u8{}
-	util.read_until_separator(mut r.reader, mut res, http_chunk_separator)?
-
-	// The length of the next chunk is provided as a hexadecimal
-	mut num_data := hex.decode(res#[..-2].bytestr())?
-
-	for num_data.len < 8 {
-		num_data.insert(0, 0)
-	}
-
-	num := binary.big_endian_u64(num_data)
-
-	// This only occurs for the very last chunk, which always reports a size of
-	// 0.
-	if num == 0 {
-		return none
-	}
-
-	return num
-}
-
-// StreamFormatReader parses an underlying stream of Docker logs, removing the
-// header bytes.
-struct StreamFormatReader {
-mut:
-	reader              ChunkedResponseReader
-	bytes_left_in_chunk u32
-}
-
-// new_stream_format_reader creates a new StreamFormatReader using the given
-// reader.
-pub fn new_stream_format_reader(reader ChunkedResponseReader) &StreamFormatReader {
-	r := &StreamFormatReader{
-		reader: reader
-	}
-
-	return r
-}
-
-// read satisfies the io.Reader interface.
-pub fn (mut r StreamFormatReader) read(mut buf []u8) ?int {
-	if r.bytes_left_in_chunk == 0 {
-		r.bytes_left_in_chunk = r.read_chunk_size()?
-	}
-
-	mut c := 0
-
-	if buf.len > r.bytes_left_in_chunk {
-		c = r.reader.read(mut buf[..r.bytes_left_in_chunk])?
-	} else {
-		c = r.reader.read(mut buf)?
-	}
-
-	r.bytes_left_in_chunk -= u32(c)
-
-	return c
-}
-
-// read_chunk_size advances the reader & reads the header bytes for the length
-// of the next chunk.
-fn (mut r StreamFormatReader) read_chunk_size() ?u32 {
-	mut buf := []u8{len: 8}
-
-	r.reader.read(mut buf)?
-
-	num := binary.big_endian_u32(buf[4..])
-
-	if num == 0 {
-		return none
-	}
-
-	return num
-}

src/env/README.md

@@ -1,7 +0,0 @@
-This module provides a framework for parsing a configuration, defined as a
-struct, from both a TOML configuration file & environment variables. Some
-notable features are:
-
-* Overwrite values in config file using environment variables
-* Allow default values in config struct
-* Read environment variable value from file

src/env/env.v

@@ -1,102 +0,0 @@
-module env
-
-import os
-import toml
-
-const (
-	// The prefix that every environment variable should have
-	prefix      = 'VIETER_'
-	// The suffix an environment variable in order for it to be loaded from a file
-	// instead
-	file_suffix = '_FILE'
-)
-
-// get_env_var tries to read the contents of the given environment variable. It
-// looks for either `${env.prefix}${field_name.to_upper()}` or
-// `${env.prefix}${field_name.to_upper()}${env.file_suffix}`, returning the
-// contents of the file instead if the latter. If both or neither exist, the
-// function returns an error.
-fn get_env_var(field_name string) ?string {
-	env_var_name := '$env.prefix$field_name.to_upper()'
-	env_file_name := '$env.prefix$field_name.to_upper()$env.file_suffix'
-	env_var := os.getenv(env_var_name)
-	env_file := os.getenv(env_file_name)
-
-	// If both are missing, we return an empty string
-	if env_var == '' && env_file == '' {
-		return ''
-	}
-
-	// If they're both set, we report a conflict
-	if env_var != '' && env_file != '' {
-		return error('Only one of $env_var_name or $env_file_name can be defined.')
-	}
-
-	// If it's the env var itself, we return it.
-	// I'm pretty sure this also prevents variable ending in _FILE (e.g.
-	// VIETER_LOG_FILE) from being mistakingely read as an _FILE suffixed env
-	// var.
-	if env_var != '' {
-		return env_var
-	}
-
-	// Otherwise, we process the file
-	return os.read_file(env_file) or {
-		error('Failed to read file defined in $env_file_name: ${err.msg()}.')
-	}
-}
-
-// load<T> attempts to create an object of type T from the given path to a toml
-// file & environment variables. For each field, it will select either a value
-// given from an environment variable, a value defined in the config file or a
-// configured default if present, in that order.
-pub fn load<T>(path string) ?T {
-	mut res := T{}
-
-	if os.exists(path) {
-		// We don't use reflect here because reflect also sets any fields not
-		// in the toml back to their zero value, which we don't want
-		doc := toml.parse_file(path)?
-
-		$for field in T.fields {
-			s := doc.value(field.name)
-
-			if s !is toml.Null {
-				$if field.typ is string {
-					res.$(field.name) = s.string()
-				} $else $if field.typ is int {
-					res.$(field.name) = s.int()
-				}
-			}
-		}
-	}
-
-	$for field in T.fields {
-		env_value := get_env_var(field.name)?
-
-		// The value of an env var will always take precedence over the toml
-		// file.
-		if env_value != '' {
-			$if field.typ is string {
-				res.$(field.name) = env_value
-			} $else $if field.typ is int {
-				res.$(field.name) = env_value.int()
-			}
-		}
-
-		// Now, we check whether a value is present. If there isn't, that means
-		// it isn't in the config file, nor is there a default or an env var.
-		mut has_value := false
-
-		$if field.typ is string {
-			has_value = res.$(field.name) != ''
-		} $else $if field.typ is int {
-			has_value = res.$(field.name) != 0
-		}
-
-		if !has_value {
-			return error("Missing config variable '$field.name' with no provided default. Either add it to the config file or provide it using an environment variable.")
-		}
-	}
-	return res
-}