diff --git a/.gitea/workflows/dev.yml b/.gitea/workflows/dev.yml new file mode 100644 index 0000000..769a0df --- /dev/null +++ b/.gitea/workflows/dev.yml @@ -0,0 +1,151 @@ +name: Dev Build, Publish & Preview Release + +on: + push: + branches: + - dev + +jobs: + build-and-publish: + name: Build, Publish Packages (Testing) & Create Preview Release + runs-on: ubuntu-latest + steps: + - name: Checkout Repository + uses: actions/checkout@v7 + + - name: Install Rust Toolchain + uses: actions-rust-lang/setup-rust-toolchain@v1 + with: + toolchain: stable + + - name: Install Packaging Tools + run: | + cargo install cargo-deb cargo-generate-rpm --locked + + - name: Run Tests + run: | + cargo test + + - name: Build Release Binary + run: | + cargo build --release + + - name: Build Debian Package (.deb) + run: | + cargo deb + + - name: Build Fedora / RPM Package (.rpm) + run: | + cargo generate-rpm + + - name: Build Arch Linux Package (.pkg.tar.zst) + run: | + chmod +x packaging/arch/build-package.sh + ./packaging/arch/build-package.sh + + - name: Publish Packages to Gitea Package Registry + env: + GITEA_URL: ${{ gitea.server_url || github.server_url }} + REPO_OWNER: ${{ gitea.repository_owner || github.repository_owner }} + TOKEN: ${{ secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }} + run: | + echo "Veröffentliche Debian-Paket (Distribution: testing, Component: main)..." + for deb in target/debian/*.deb; do + [ -f "$deb" ] || continue + curl -f -s -S -X PUT \ + -H "Authorization: token ${TOKEN}" \ + --upload-file "$deb" \ + "${GITEA_URL}/api/packages/${REPO_OWNER}/debian/pool/testing/main/upload" + done + + echo "Veröffentliche Fedora/RPM-Paket (Gruppe: testing)..." + for rpm in target/generate-rpm/*.rpm; do + [ -f "$rpm" ] || continue + curl -f -s -S -X PUT \ + -H "Authorization: token ${TOKEN}" \ + --upload-file "$rpm" \ + "${GITEA_URL}/api/packages/${REPO_OWNER}/rpm/testing/upload" + done + + echo "Veröffentliche Arch Linux-Paket (Repository: testing)..." + for pkg in target/arch/*.pkg.tar.zst; do + [ -f "$pkg" ] || continue + curl -f -s -S -X PUT \ + -H "Authorization: token ${TOKEN}" \ + --upload-file "$pkg" \ + "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/testing/upload" + done + + - name: Create Gitea Pre-Release and Upload Assets + env: + GITEA_URL: ${{ gitea.server_url || github.server_url }} + REPO: ${{ gitea.repository || github.repository }} + TOKEN: ${{ secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }} + run: | + VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)" + TAG_NAME="v${VERSION}-preview" + RELEASE_TITLE="Preview Release ${TAG_NAME}" + RELEASE_NOTES="Automatisches Preview-Release für docker-update ${VERSION} (Branch: dev)." + + echo "Erstelle oder hole Preview-Release für Tag ${TAG_NAME} in ${REPO}..." + + GET_RESP=$(curl -s -w "\n%{http_code}" \ + -H "Authorization: token ${TOKEN}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/tags/${TAG_NAME}") + HTTP_CODE=$(echo "$GET_RESP" | tail -n1) + BODY=$(echo "$GET_RESP" | sed '$d') + + RELEASE_ID="" + if [ "$HTTP_CODE" -eq 200 ]; then + RELEASE_ID=$(echo "$BODY" | jq -r '.id // empty' 2>/dev/null || echo "$BODY" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2) + echo "Bestehendes Release gefunden (ID: ${RELEASE_ID})." + else + echo "Erstelle neues Preview-Release ${TAG_NAME}..." + CREATE_PAYLOAD=$(cat </dev/null || echo "$CREATE_RESP" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2) + echo "Neues Preview-Release erstellt (ID: ${RELEASE_ID})." + fi + + if [ -z "$RELEASE_ID" ]; then + echo "Fehler: Release-ID konnte nicht ermittelt werden!" + exit 1 + fi + + EXISTING_ASSETS_JSON=$(curl -s \ + -H "Authorization: token ${TOKEN}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets" || echo "[]") + + for file in target/debian/*.deb target/generate-rpm/*.rpm target/arch/*.pkg.tar.zst; do + [ -f "$file" ] || continue + filename="$(basename "$file")" + echo "Lade Release-Asset hoch: $filename" + + ASSET_ID=$(echo "$EXISTING_ASSETS_JSON" | jq -r --arg name "$filename" '.[]? | select(.name == $name) | .id' 2>/dev/null | head -n1 || true) + if [ -n "$ASSET_ID" ] && [ "$ASSET_ID" != "null" ]; then + echo "Lösche altes Asset mit ID ${ASSET_ID}..." + curl -s -X DELETE \ + -H "Authorization: token ${TOKEN}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets/${ASSET_ID}" || true + fi + + curl -f -s -S -X POST \ + -H "Authorization: token ${TOKEN}" \ + -F "attachment=@${file}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets?name=${filename}" + echo "Asset ${filename} erfolgreich hochgeladen." + done diff --git a/.gitea/workflows/main.yml b/.gitea/workflows/main.yml new file mode 100644 index 0000000..9f24c2d --- /dev/null +++ b/.gitea/workflows/main.yml @@ -0,0 +1,151 @@ +name: Main Release & Publish + +on: + push: + branches: + - main + +jobs: + release-and-publish: + name: Build, Publish Packages (Stable) & Create Release + runs-on: ubuntu-latest + steps: + - name: Checkout Repository + uses: actions/checkout@v4 + + - name: Install Rust Toolchain + uses: actions-rust-lang/setup-rust-toolchain@v1 + with: + toolchain: stable + + - name: Install Packaging Tools + run: | + cargo install cargo-deb cargo-generate-rpm --locked + + - name: Run Tests + run: | + cargo test + + - name: Build Release Binary + run: | + cargo build --release + + - name: Build Debian Package (.deb) + run: | + cargo deb + + - name: Build Fedora / RPM Package (.rpm) + run: | + cargo generate-rpm + + - name: Build Arch Linux Package (.pkg.tar.zst) + run: | + chmod +x packaging/arch/build-package.sh + ./packaging/arch/build-package.sh + + - name: Publish Packages to Gitea Package Registry + env: + GITEA_URL: ${{ gitea.server_url || github.server_url }} + REPO_OWNER: ${{ gitea.repository_owner || github.repository_owner }} + TOKEN: ${{ secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }} + run: | + echo "Veröffentliche Debian-Paket (Distribution: stable, Component: main)..." + for deb in target/debian/*.deb; do + [ -f "$deb" ] || continue + curl -f -s -S -X PUT \ + -H "Authorization: token ${TOKEN}" \ + --upload-file "$deb" \ + "${GITEA_URL}/api/packages/${REPO_OWNER}/debian/pool/stable/main/upload" + done + + echo "Veröffentliche Fedora/RPM-Paket (Gruppe: stable)..." + for rpm in target/generate-rpm/*.rpm; do + [ -f "$rpm" ] || continue + curl -f -s -S -X PUT \ + -H "Authorization: token ${TOKEN}" \ + --upload-file "$rpm" \ + "${GITEA_URL}/api/packages/${REPO_OWNER}/rpm/stable/upload" + done + + echo "Veröffentliche Arch Linux-Paket (Repository: stable)..." + for pkg in target/arch/*.pkg.tar.zst; do + [ -f "$pkg" ] || continue + curl -f -s -S -X PUT \ + -H "Authorization: token ${TOKEN}" \ + --upload-file "$pkg" \ + "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/stable/upload" + done + + - name: Create Gitea Release and Upload Assets + env: + GITEA_URL: ${{ gitea.server_url || github.server_url }} + REPO: ${{ gitea.repository || github.repository }} + TOKEN: ${{ secrets.GITEA_TOKEN || secrets.GITHUB_TOKEN || github.token }} + run: | + VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)" + TAG_NAME="v${VERSION}" + RELEASE_TITLE="Release ${TAG_NAME}" + RELEASE_NOTES="Automatisches Release für docker-update ${VERSION}." + + echo "Erstelle oder hole Release für Tag ${TAG_NAME} in ${REPO}..." + + GET_RESP=$(curl -s -w "\n%{http_code}" \ + -H "Authorization: token ${TOKEN}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/tags/${TAG_NAME}") + HTTP_CODE=$(echo "$GET_RESP" | tail -n1) + BODY=$(echo "$GET_RESP" | sed '$d') + + RELEASE_ID="" + if [ "$HTTP_CODE" -eq 200 ]; then + RELEASE_ID=$(echo "$BODY" | jq -r '.id // empty' 2>/dev/null || echo "$BODY" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2) + echo "Bestehendes Release gefunden (ID: ${RELEASE_ID})." + else + echo "Erstelle neues Release ${TAG_NAME}..." + CREATE_PAYLOAD=$(cat </dev/null || echo "$CREATE_RESP" | grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2) + echo "Neues Release erstellt (ID: ${RELEASE_ID})." + fi + + if [ -z "$RELEASE_ID" ]; then + echo "Fehler: Release-ID konnte nicht ermittelt werden!" + exit 1 + fi + + EXISTING_ASSETS_JSON=$(curl -s \ + -H "Authorization: token ${TOKEN}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets" || echo "[]") + + for file in target/debian/*.deb target/generate-rpm/*.rpm target/arch/*.pkg.tar.zst; do + [ -f "$file" ] || continue + filename="$(basename "$file")" + echo "Lade Release-Asset hoch: $filename" + + ASSET_ID=$(echo "$EXISTING_ASSETS_JSON" | jq -r --arg name "$filename" '.[]? | select(.name == $name) | .id' 2>/dev/null | head -n1 || true) + if [ -n "$ASSET_ID" ] && [ "$ASSET_ID" != "null" ]; then + echo "Lösche altes Asset mit ID ${ASSET_ID}..." + curl -s -X DELETE \ + -H "Authorization: token ${TOKEN}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets/${ASSET_ID}" || true + fi + + curl -f -s -S -X POST \ + -H "Authorization: token ${TOKEN}" \ + -F "attachment=@${file}" \ + "${GITEA_URL}/api/v1/repos/${REPO}/releases/${RELEASE_ID}/assets?name=${filename}" + echo "Asset ${filename} erfolgreich hochgeladen." + done diff --git a/.idea/jsonSchemas.xml b/.idea/jsonSchemas.xml new file mode 100644 index 0000000..9b965ac --- /dev/null +++ b/.idea/jsonSchemas.xml @@ -0,0 +1,28 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/AGENTS.md b/AGENTS.md index af607ed..1d03492 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -27,6 +27,10 @@ lädt diese herunter, startet betroffene Services neu und bereinigt ungenutzte Z ```text DockerUpdate/ +├── .gitea/ +│ └── workflows/ +│ ├── dev.yml # CI/CD für dev-Branch (Tests, Testing-Packages & Preview-Release) +│ └── main.yml # CI/CD für main-Branch (Tests, Stable-Packages & Release) ├── Cargo.toml # Rust-Manifest, Abhängigkeiten und Metadaten für cargo-deb / generate-rpm ├── Cargo.lock ├── LICENSE # GPL-3.0 Lizenztext @@ -34,9 +38,10 @@ DockerUpdate/ ├── AGENTS.md # Richtlinien und Dokumentation für Agenten ├── packaging/ │ ├── arch/ -│ │ └── PKGBUILD # Arch Linux PKGBUILD +│ │ ├── PKGBUILD # Arch Linux PKGBUILD +│ │ └── build-package.sh # Hilfsskript zur Erstellung des .pkg.tar.zst-Pakets │ └── fedora/ -│ └── docker-update.spec # RPM-Spec für Fedora / RHEL / CentOS +│ └── docker-update.spec # RPM-Spec für Fedora / RHEL / CentOS └── src/ ├── main.rs # Einstiegspunkt, Root-Prüfung, Ausführung ├── program.rs # Hilfsfunktion zur Programmnamensermittlung @@ -70,6 +75,17 @@ DockerUpdate/ - **`src/sudo.rs`**: - `is_run_as_root()`: Nutzt `libc::geteuid() == 0`. - `run_as_root()`: Führt `sudo ` per `exec` aus. +- **`.gitea/workflows/`**: + - `dev.yml`: Führt bei Push auf `dev` Tests und Builds durch, veröffentlicht Pakete in der Gitea Package Registry + (`distribution: testing`, `component: main` bzw. Gruppe/Repo `testing`) und erstellt ein Gitea Preview-Release mit + den Paketen als Assets. + - `main.yml`: Führt bei Push auf `main` Tests und Builds durch, veröffentlicht Pakete in der Gitea Package Registry + (`distribution: stable`, `component: main` bzw. Gruppe/Repo `stable`) und erstellt ein Gitea Release mit den + Paketen als Assets. +- **`packaging/`**: + - `arch/PKGBUILD`: Quellpaketdefinition für Arch Linux (AUR / Makepkg). + - `arch/build-package.sh`: Hilfsskript zum Bauen des standardkonformen `.pkg.tar.zst`-Pakets aus dem Cargo-Build. + - `fedora/docker-update.spec`: RPM-Spec-Datei für Fedora, RHEL und CentOS. --- @@ -88,6 +104,19 @@ cargo test cargo build --release ``` +### Optionale Paketierungsbefehle (lokale Validierung) + +```bash +# Debian-Paket (.deb) erstellen (benötigt cargo-deb) +cargo deb + +# Fedora / RPM-Paket (.rpm) erstellen (benötigt cargo-generate-rpm) +cargo generate-rpm + +# Arch Linux-Paket (.pkg.tar.zst) erstellen +./packaging/arch/build-package.sh +``` + --- ## 4. Richtlinien für Änderungen @@ -95,10 +124,13 @@ cargo build --release 1. **Abwärtskompatibilität & Pfade**: Der Standard-Apps-Pfad `/var/apps` und die Konfigurationspfade dürfen nicht ohne triftigen Grund geändert werden. 2. **Paketierungsdefinitionen synchron halten**: - Werden Abhängigkeiten oder Assets geändert, müssen `Cargo.toml` (`[package.metadata.deb]`, - `[package.metadata.generate-rpm]`), `packaging/arch/PKGBUILD` und `packaging/fedora/docker-update.spec` entsprechend - aktualisiert werden. + Werden Abhängigkeiten, Metadaten oder Assets geändert, müssen `Cargo.toml` (`[package.metadata.deb]`, + `[package.metadata.generate-rpm]`), `packaging/arch/PKGBUILD`, `packaging/arch/build-package.sh` und + `packaging/fedora/docker-update.spec` entsprechend aktualisiert werden. 3. **Automatisierung**: Die empfohlene Automatisierungsmethode ist **Cron** (`/etc/cron.d/docker-update` oder `crontab -e`). 4. **Keine Mocking-Bypässe**: Tests dürfen nicht gelöscht, ignoriert oder durch leere Dummy-Assertions ersetzt werden. +5. **CI/CD & Release-Konsistenz**: + Workflows in `.gitea/workflows/` müssen bei strukturellen Paket- oder Release-Anpassungen konsistent zu `Cargo.toml` + gehalten werden. diff --git a/README.md b/README.md index d1d7fe4..37cd265 100644 --- a/README.md +++ b/README.md @@ -38,6 +38,126 @@ auf neuere Versionen prüft, aktualisiert und neu startet. --- +## Installation aus der Gitea-Paket-Registry + +Über die CI/CD-Pipelines werden bei jedem Push auf den `main`-Branch (Release / Stable) und `dev`-Branch (Preview / +Testing) automatisch Pakete für **Debian/Ubuntu**, **Fedora/RHEL** und **Arch Linux** in der Gitea-Paket-Registry +bereitgestellt. + +### 1. Debian / Ubuntu (`apt`) + +#### Stable (Produktiv) + +Füge das Repository zu deinen APT-Quellen hinzu: + +```bash +# Keyring installieren +sudo curl https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian/repository.key -o /etc/apt/keyrings/gitea-Linuxapps.asc +# Repository-Eintrag anlegen +echo "deb [signed-by=/etc/apt/keyrings/gitea-Linuxapps.asc] https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian stable main" | sudo tee -a /etc/apt/sources.list.d/gitea.list + +# Paketliste aktualisieren und installieren +sudo apt update +sudo apt install docker-update +``` + +#### Testing (Vorschau / Dev) + +```bash +# Keyring installieren +sudo curl https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian/repository.key -o /etc/apt/keyrings/gitea-Linuxapps.asc +# Testing-Repository-Eintrag anlegen +echo "deb [signed-by=/etc/apt/keyrings/gitea-Linuxapps.asc] https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/debian testing main" | sudo tee -a /etc/apt/sources.list.d/gitea.list + +# Paketliste aktualisieren und installieren +sudo apt update +sudo apt install docker-update +``` + +--- + +### 2. Fedora / RHEL / CentOS (`dnf` / `yum`) + +#### Stable (Produktiv) + +Erstelle die Repository-Datei `/etc/yum.repos.d/docker-update.repo`: + +```bash +sudo tee /etc/yum.repos.d/docker-update-stable.repo << 'EOF' +[docker-update-stable] +name=DockerUpdate Stable +baseurl=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/stable +enabled=1 +gpgcheck=0 +EOF + +# Installation via DNF +sudo dnf install docker-update +``` + +#### Testing (Vorschau / Dev) + +```bash +sudo tee /etc/yum.repos.d/docker-update-testing.repo << 'EOF' +[docker-update-testing] +name=DockerUpdate Testing +baseurl=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/testing +enabled=1 +gpgcheck=0 +EOF + +# Installation via DNF +sudo dnf install docker-update +``` + +--- + +### 3. Arch Linux (`pacman`) + +#### Stable (Produktiv) + +Füge das Repository in `/etc/pacman.conf` ein: + +```ini +[docker-update-stable] +SigLevel = Optional TrustAll +Server = https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/arch/stable/$arch +``` + +Installiere das Paket anschließend: + +```bash +sudo pacman -Sy docker-update +``` + +#### Testing (Vorschau / Dev) + +Füge das Testing-Repository in `/etc/pacman.conf` ein: + +```ini +[docker-update-testing] +SigLevel = Optional TrustAll +Server = https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/arch/testing/$arch +``` + +Installiere das Paket: + +```bash +sudo pacman -Sy docker-update +``` + +--- + +### Download vorgefertigter Pakete (Releases) + +Alternativ können vorkompilierte Pakete (`.deb`, `.rpm`, `.pkg.tar.zst`) auch direkt aus den Releases heruntergeladen +und manuell installiert werden: + +- **Stable-Releases**: [Gitea Releases](https://gitea.creative-dragonslayer.de/Linuxapps/DockerUpdate/releases) +- **Preview-Releases (Testing)**: Markiert als Vorabveröffentlichung (*Pre-release*) mit dem Tag `v-preview`. + +--- + ## Manuelle Installation (Build from Source) ```bash diff --git a/packaging/arch/build-package.sh b/packaging/arch/build-package.sh new file mode 100755 index 0000000..8c22a03 --- /dev/null +++ b/packaging/arch/build-package.sh @@ -0,0 +1,54 @@ +#!/usr/bin/env bash +set -euo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)" + +cd "$PROJECT_ROOT" + +if [ ! -f "target/release/docker-update" ]; then + cargo build --release +fi + +VERSION="$(sed -n 's/^version = "\(.*\)"/\1/p' Cargo.toml | head -n1)" +PKGVER="${VERSION}" +PKGREL="1" +ARCH="x86_64" + +BUILD_DIR="$(mktemp -d)" +trap 'rm -rf "$BUILD_DIR"' EXIT + +mkdir -p "$BUILD_DIR/usr/bin" +mkdir -p "$BUILD_DIR/usr/share/licenses/docker-update" +mkdir -p "$BUILD_DIR/usr/share/doc/docker-update" + +install -m 755 "target/release/docker-update" "$BUILD_DIR/usr/bin/docker-update" +install -m 644 "LICENSE" "$BUILD_DIR/usr/share/licenses/docker-update/LICENSE" +install -m 644 "README.md" "$BUILD_DIR/usr/share/doc/docker-update/README.md" + +INSTALLED_SIZE="$(du -sb "$BUILD_DIR" | awk '{print $1}')" + +cat < "$BUILD_DIR/.PKGINFO" +pkgname = docker-update +pkgbase = docker-update +pkgver = ${PKGVER}-${PKGREL} +pkgdesc = Automatisches Aktualisieren von Docker-Compose-Anwendungen in /var/apps mit :latest-Images +url = https://gitea.creative-dragonslayer.de/Linuxapps/DockerUpdate +builddate = $(date +%s) +packager = DragonSlayer_14 +size = ${INSTALLED_SIZE} +arch = ${ARCH} +license = GPL-3.0-or-later +depend = gcc-libs +depend = glibc +depend = sudo +depend = docker +optdepend = docker-compose: Unterstützung für Docker Compose v1 +makepkgopt = strip +EOF + +mkdir -p "target/arch" +OUTPUT_FILE="$PROJECT_ROOT/target/arch/docker-update-${PKGVER}-${PKGREL}-${ARCH}.pkg.tar.zst" +(cd "$BUILD_DIR" && tar --zstd -cf "$OUTPUT_FILE" .PKGINFO usr) + +echo "Arch-Paket erfolgreich erstellt: $OUTPUT_FILE" diff --git a/src/updater.rs b/src/updater.rs index 24b24d4..778bbc8 100644 --- a/src/updater.rs +++ b/src/updater.rs @@ -1,10 +1,10 @@ +use crate::config; +use crate::log::{LogLevel, log}; +use serde::Deserialize; +use std::collections::HashMap; use std::fs; use std::path::{Path, PathBuf}; use std::process::{Command, Output}; -use serde::Deserialize; -use std::collections::HashMap; -use crate::log::{log, LogLevel}; -use crate::config; const COMPOSE_FILENAMES: &[&str] = &[ "docker-compose.yaml", @@ -58,11 +58,21 @@ pub fn find_compose_file(dir: &Path) -> Option { /// Liest eine Compose-Datei ein und liefert eine Liste von (Service-Name, Image-Name). pub fn parse_compose_services(compose_path: &Path) -> Result, String> { - let content = fs::read_to_string(compose_path) - .map_err(|e| format!("Fehler beim Lesen der Datei '{}': {}", compose_path.display(), e))?; + let content = fs::read_to_string(compose_path).map_err(|e| { + format!( + "Fehler beim Lesen der Datei '{}': {}", + compose_path.display(), + e + ) + })?; - let compose: ComposeFile = serde_yaml::from_str(&content) - .map_err(|e| format!("Fehler beim Parsen der YAML-Datei '{}': {}", compose_path.display(), e))?; + let compose: ComposeFile = serde_yaml::from_str(&content).map_err(|e| { + format!( + "Fehler beim Parsen der YAML-Datei '{}': {}", + compose_path.display(), + e + ) + })?; let mut services = Vec::new(); for (service_name, config) in compose.services { @@ -126,7 +136,10 @@ pub fn pull_image(image: &str) -> Result { if !output.status.success() { let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string(); - return Err(format!("'docker pull {}' fehlgeschlagen: {}", image, stderr)); + return Err(format!( + "'docker pull {}' fehlgeschlagen: {}", + image, stderr + )); } let stdout_str = String::from_utf8_lossy(&output.stdout); @@ -159,22 +172,53 @@ pub fn restart_compose_service(dir: &Path, service_name: Option<&str>) -> Result Ok(()) } +/// Bereinigt ungenutzte Zwischen-Images via `docker image prune -f`. +pub fn prune_images() -> Result<(), String> { + let output = run_docker_command(&["image", "prune", "-f"]) + .map_err(|e| format!("Fehler beim Ausführen von 'docker image prune -f': {}", e))?; + + if !output.status.success() { + let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string(); + return Err(format!( + "'docker image prune -f' fehlgeschlagen: {}", + stderr + )); + } + + Ok(()) +} + /// Prüft alle Unterverzeichnisse im konfigurierten Apps-Verzeichnis auf Aktualisierungen. pub fn run_updates() { let config = config::get_config(); let apps_dir_path = Path::new(&config.general.apps_dir); - log("scanner", &format!("Überprüfe Anwendungsverzeichnis: {}", apps_dir_path.display()), LogLevel::Info); + log( + "scanner", + &format!( + "Überprüfe Anwendungsverzeichnis: {}", + apps_dir_path.display() + ), + LogLevel::Info, + ); if !apps_dir_path.exists() { - log("scanner", &format!("Verzeichnis '{}' existiert nicht.", apps_dir_path.display()), LogLevel::Warn); + log( + "scanner", + &format!("Verzeichnis '{}' existiert nicht.", apps_dir_path.display()), + LogLevel::Warn, + ); return; } let entries = match fs::read_dir(apps_dir_path) { Ok(e) => e, Err(e) => { - log("scanner", &format!("Fehler beim Lesen von '{}': {}", apps_dir_path.display(), e), LogLevel::Error); + log( + "scanner", + &format!("Fehler beim Lesen von '{}': {}", apps_dir_path.display(), e), + LogLevel::Error, + ); return; } }; @@ -187,28 +231,58 @@ pub fn run_updates() { app_dirs.sort(); if app_dirs.is_empty() { - log("scanner", &format!("Keine Unterverzeichnisse in '{}' gefunden.", apps_dir_path.display()), LogLevel::Info); + log( + "scanner", + &format!( + "Keine Unterverzeichnisse in '{}' gefunden.", + apps_dir_path.display() + ), + LogLevel::Info, + ); return; } for app_dir in app_dirs { let app_name = app_dir.file_name().unwrap_or_default().to_string_lossy(); - log("scanner", &format!("Untersuche Anwendung '{}'...", app_name), LogLevel::Info); + log( + "scanner", + &format!("Untersuche Anwendung '{}'...", app_name), + LogLevel::Info, + ); let compose_file = match find_compose_file(&app_dir) { Some(f) => f, None => { - log("scanner", &format!("Keine Docker-Compose-Datei in '{}' gefunden. Überspringe.", app_dir.display()), LogLevel::Debug); + log( + "scanner", + &format!( + "Keine Docker-Compose-Datei in '{}' gefunden. Überspringe.", + app_dir.display() + ), + LogLevel::Debug, + ); continue; } }; - log("compose", &format!("Gefundene Compose-Datei: {}", compose_file.display()), LogLevel::Debug); + log( + "compose", + &format!("Gefundene Compose-Datei: {}", compose_file.display()), + LogLevel::Debug, + ); let services = match parse_compose_services(&compose_file) { Ok(s) => s, Err(e) => { - log("compose", &format!("Fehler beim Analysieren von '{}': {}", compose_file.display(), e), LogLevel::Warn); + log( + "compose", + &format!( + "Fehler beim Analysieren von '{}': {}", + compose_file.display(), + e + ), + LogLevel::Warn, + ); continue; } }; @@ -217,40 +291,107 @@ pub fn run_updates() { for (service_name, image) in services { if !is_latest_image(&image) { - log("updater", &format!("Service '{}' verwendet kein :latest-Image ('{}'). Überspringe.", service_name, image), LogLevel::Debug); + log( + "updater", + &format!( + "Service '{}' verwendet kein :latest-Image ('{}'). Überspringe.", + service_name, image + ), + LogLevel::Debug, + ); continue; } - log("updater", &format!("Prüfe auf neues Image für Service '{}' ('{}')...", service_name, image), LogLevel::Info); + log( + "updater", + &format!( + "Prüfe auf neues Image für Service '{}' ('{}')...", + service_name, image + ), + LogLevel::Info, + ); match pull_image(&image) { Ok(true) => { - log("updater", &format!("Neueres Image für Service '{}' ('{}') gefunden und heruntergeladen.", service_name, image), LogLevel::Info); + log( + "updater", + &format!( + "Neueres Image für Service '{}' ('{}') gefunden und heruntergeladen.", + service_name, image + ), + LogLevel::Info, + ); updated_any = true; } Ok(false) => { - log("updater", &format!("Image für Service '{}' ('{}') ist bereits aktuell.", service_name, image), LogLevel::Info); + log( + "updater", + &format!( + "Image für Service '{}' ('{}') ist bereits aktuell.", + service_name, image + ), + LogLevel::Info, + ); } Err(e) => { - log("updater", &format!("Fehler beim Aktualisieren von Image '{}': {}", image, e), LogLevel::Error); + log( + "updater", + &format!("Fehler beim Aktualisieren von Image '{}': {}", image, e), + LogLevel::Error, + ); } } } if updated_any { - log("updater", &format!("Starte Anwendung '{}' neu mit aktualisierten Images...", app_name), LogLevel::Info); + log( + "updater", + &format!( + "Starte Anwendung '{}' neu mit aktualisierten Images...", + app_name + ), + LogLevel::Info, + ); match restart_compose_service(&app_dir, None) { Ok(_) => { - log("updater", &format!("Anwendung '{}' erfolgreich aktualisiert und neu gestartet.", app_name), LogLevel::Info); + log( + "updater", + &format!( + "Anwendung '{}' erfolgreich aktualisiert und neu gestartet.", + app_name + ), + LogLevel::Info, + ); } Err(e) => { - log("updater", &format!("Fehler beim Neustarten der Anwendung '{}': {}", app_name, e), LogLevel::Error); + log( + "updater", + &format!("Fehler beim Neustarten der Anwendung '{}': {}", app_name, e), + LogLevel::Error, + ); } } + + log( + "updater", + "Bereinige ungenutzte Docker-Images...", + LogLevel::Info, + ); + if let Err(e) = prune_images() { + log( + "updater", + &format!("Fehler beim Bereinigen ungenutzter Docker-Images: {}", e), + LogLevel::Warn, + ); + } } } - log("scanner", "Aktualisierungsvorgang abgeschlossen.", LogLevel::Info); + log( + "scanner", + "Aktualisierungsvorgang abgeschlossen.", + LogLevel::Info, + ); } #[cfg(test)]