Merge pull request 'Merge testing in main: 1.0.2 Release' (#17) from testing into main

Reviewed-on: #17

.cargo/config.toml

@@ -0,0 +1,5 @@
+[target.aarch64-unknown-linux-gnu]
+linker = "aarch64-linux-gnu-gcc"
+
+[target.i686-unknown-linux-gnu]
+linker = "i686-linux-gnu-gcc"

.gitea/workflows/main.yaml

@@ -11,43 +11,61 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v7
 
       - name: Install Rust Toolchain
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           toolchain: stable
+          cache: false
 
-      - name: Install Packaging Tools
+      - name: Install Cross-Compilation Toolchains & Dependencies
         run: |
-          cargo install cargo-deb cargo-generate-rpm --locked
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu gcc-i686-linux-gnu
+          rustup target add x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu i686-unknown-linux-gnu
+
+      - name: Install Packaging Tools (Prebuilt Binaries)
+        run: |
+          mkdir -p ~/.cargo/bin
+          curl -fsSL https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz | tar -xz -C ~/.cargo/bin
+          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+          ~/.cargo/bin/cargo-binstall -y --no-symlinks cargo-deb cargo-generate-rpm
 
       - name: Run Tests
         run: |
           cargo test
 
-      - name: Build Release Binary
+      - name: Build Release Binaries
         run: |
-          cargo build --release
+          cargo build --release --target x86_64-unknown-linux-gnu
+          cargo build --release --target aarch64-unknown-linux-gnu
+          cargo build --release --target i686-unknown-linux-gnu
 
-      - name: Build Debian Package (.deb)
+      - name: Build Debian Packages (.deb)
         run: |
-          cargo deb
+          cargo deb --target x86_64-unknown-linux-gnu --no-build
+          cargo deb --target aarch64-unknown-linux-gnu --no-build
+          cargo deb --target i686-unknown-linux-gnu --no-build
 
-      - name: Build Fedora / RPM Package (.rpm)
+      - name: Build Fedora / RPM Packages (.rpm)
         run: |
-          cargo generate-rpm
+          mkdir -p target/generate-rpm
+          cargo generate-rpm --target x86_64-unknown-linux-gnu -o target/generate-rpm
+          cargo generate-rpm --target aarch64-unknown-linux-gnu -o target/generate-rpm
+          cargo generate-rpm --target i686-unknown-linux-gnu -o target/generate-rpm
 
-      - name: Build Arch Linux Package (.pkg.tar.zst)
+      - name: Build Arch Linux Packages (.pkg.tar.zst)
         run: |
-          chmod +x packaging/arch/build-package.sh
+          python3 scripts/package-arch.py --target x86_64-unknown-linux-gnu
-          ./packaging/arch/build-package.sh
+          python3 scripts/package-arch.py --target aarch64-unknown-linux-gnu
+          python3 scripts/package-arch.py --target i686-unknown-linux-gnu
 
       - 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 }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_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
@@ -73,14 +91,14 @@ jobs:
             curl -f -s -S -X PUT \
               -H "Authorization: token ${TOKEN}" \
               --upload-file "$pkg" \
-              "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/stable/upload"
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/stable"
           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 }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_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}"

.gitea/workflows/testing.yaml

@@ -1,9 +1,9 @@
-name: Dev Build, Publish & Preview Release
+name: Testing Build, Publish & Preview Release
 
 on:
   push:
     branches:
-      - dev
+      - testing
 
 jobs:
   build-and-publish:
@@ -17,37 +17,55 @@ jobs:
         uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
           toolchain: stable
+          cache: false
 
-      - name: Install Packaging Tools
+      - name: Install Cross-Compilation Toolchains & Dependencies
         run: |
-          cargo install cargo-deb cargo-generate-rpm --locked
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu gcc-i686-linux-gnu
+          rustup target add x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu i686-unknown-linux-gnu
+
+      - name: Install Packaging Tools (Prebuilt Binaries)
+        run: |
+          mkdir -p ~/.cargo/bin
+          curl -fsSL https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz | tar -xz -C ~/.cargo/bin
+          echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+          ~/.cargo/bin/cargo-binstall -y --no-symlinks cargo-deb cargo-generate-rpm
 
       - name: Run Tests
         run: |
           cargo test
 
-      - name: Build Release Binary
+      - name: Build Release Binaries
         run: |
-          cargo build --release
+          cargo build --release --target x86_64-unknown-linux-gnu
+          cargo build --release --target aarch64-unknown-linux-gnu
+          cargo build --release --target i686-unknown-linux-gnu
 
-      - name: Build Debian Package (.deb)
+      - name: Build Debian Packages (.deb)
         run: |
-          cargo deb
+          cargo deb --target x86_64-unknown-linux-gnu --no-build
+          cargo deb --target aarch64-unknown-linux-gnu --no-build
+          cargo deb --target i686-unknown-linux-gnu --no-build
 
-      - name: Build Fedora / RPM Package (.rpm)
+      - name: Build Fedora / RPM Packages (.rpm)
         run: |
-          cargo generate-rpm
+          mkdir -p target/generate-rpm
+          cargo generate-rpm --target x86_64-unknown-linux-gnu -o target/generate-rpm
+          cargo generate-rpm --target aarch64-unknown-linux-gnu -o target/generate-rpm
+          cargo generate-rpm --target i686-unknown-linux-gnu -o target/generate-rpm
 
-      - name: Build Arch Linux Package (.pkg.tar.zst)
+      - name: Build Arch Linux Packages (.pkg.tar.zst)
         run: |
-          chmod +x packaging/arch/build-package.sh
+          python3 scripts/package-arch.py --target x86_64-unknown-linux-gnu
-          ./packaging/arch/build-package.sh
+          python3 scripts/package-arch.py --target aarch64-unknown-linux-gnu
+          python3 scripts/package-arch.py --target i686-unknown-linux-gnu
 
       - 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 }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_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
@@ -73,19 +91,19 @@ jobs:
             curl -f -s -S -X PUT \
               -H "Authorization: token ${TOKEN}" \
               --upload-file "$pkg" \
-              "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/testing/upload"
+              "${GITEA_URL}/api/packages/${REPO_OWNER}/arch/testing"
           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 }}
+          TOKEN: ${{ secrets.PACKAGE_TOKEN || secrets.RELEASE_TOKEN || secrets.PUBLISH_TOKEN || secrets.API_TOKEN || secrets.PAT_TOKEN || secrets.CUSTOM_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)."
+          RELEASE_NOTES="Automatisches Preview-Release für docker-update ${VERSION} (Branch: Testing)."
 
           echo "Erstelle oder hole Preview-Release für Tag ${TAG_NAME} in ${REPO}..."
 
@@ -104,7 +122,7 @@ jobs:
             CREATE_PAYLOAD=$(cat <<EOF
           {
             "tag_name": "${TAG_NAME}",
-            "target_commitish": "dev",
+            "target_commitish": "testing",
             "name": "${RELEASE_TITLE}",
             "body": "${RELEASE_NOTES}",
             "draft": false,

.idea/jsonSchemas.xml

@@ -12,10 +12,10 @@
               <option name="patterns">
                 <list>
                   <Item>
-                    <option name="path" value=".gitea/workflows/dev.yml" />
+                    <option name="path" value=".gitea/workflows/testing.yaml" />
                   </Item>
                   <Item>
-                    <option name="path" value=".gitea/workflows/main.yml" />
+                    <option name="path" value=".gitea/workflows/main.yaml" />
                   </Item>
                 </list>
               </option>

AGENTS.md

@@ -29,19 +29,15 @@ lädt diese herunter, startet betroffene Services neu und bereinigt ungenutzte Z
 DockerUpdate/
 ├── .gitea/
 │   └── workflows/
-│       ├── dev.yml     # CI/CD für dev-Branch (Tests, Testing-Packages & Preview-Release)
+│       ├── testing.yaml # CI/CD für testing-Branch (Tests, Testing-Packages & Preview-Release)
-│       └── main.yml    # CI/CD für main-Branch (Tests, Stable-Packages & Release)
+│       └── main.yaml    # CI/CD für main-Branch (Tests, Stable-Packages & Release)
-├── Cargo.toml          # Rust-Manifest, Abhängigkeiten und Metadaten für cargo-deb / generate-rpm
+├── scripts/
+│   └── package-arch.py  # Hilfsskript zur Arch-Linux-Paketerstellung (.pkg.tar.zst)
+├── Cargo.toml          # Rust-Manifest, Abhängigkeiten und Metadaten für deb / generate-rpm / arch
 ├── Cargo.lock
 ├── LICENSE             # GPL-3.0 Lizenztext
 ├── README.md           # Projektdokumentation für Endanwender und Administratoren
 ├── AGENTS.md           # Richtlinien und Dokumentation für Agenten
-├── packaging/
-│   ├── arch/
-│   │   ├── 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
 └── src/
     ├── main.rs         # Einstiegspunkt, Root-Prüfung, Ausführung
     ├── program.rs      # Hilfsfunktion zur Programmnamensermittlung
@@ -76,16 +72,13 @@ DockerUpdate/
     - `is_run_as_root()`: Nutzt `libc::geteuid() == 0`.
     - `run_as_root()`: Führt `sudo <args>` 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
+    - `testing.yaml`: Führt bei Push auf `testing` 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
+    - `main.yaml`: 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.
 
 ---
 
@@ -114,7 +107,7 @@ cargo deb
 cargo generate-rpm
 
 # Arch Linux-Paket (.pkg.tar.zst) erstellen
-./packaging/arch/build-package.sh
+python3 scripts/package-arch.py
 ```
 
 ---
@@ -123,10 +116,10 @@ cargo generate-rpm
 
 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**:
+2. **Paketierungsdefinitionen in Cargo.toml pflegen**:
-   Werden Abhängigkeiten, Metadaten oder Assets geändert, müssen `Cargo.toml` (`[package.metadata.deb]`,
+   Alle Paketierungsdefinitionen für Debian, RPM und Arch Linux werden zentral in `Cargo.toml` verwaltet
-   `[package.metadata.generate-rpm]`), `packaging/arch/PKGBUILD`, `packaging/arch/build-package.sh` und
+   (`[package.metadata.deb]`, `[package.metadata.generate-rpm]`, `[package.metadata.arch]`). Es wird kein separater
-   `packaging/fedora/docker-update.spec` entsprechend aktualisiert werden.
+   `packaging/`-Ordner benötigt.
 3. **Automatisierung**:
    Die empfohlene Automatisierungsmethode ist **Cron** (`/etc/cron.d/docker-update` oder `crontab -e`).
 4. **Keine Mocking-Bypässe**:

Cargo.lock

@@ -29,7 +29,7 @@ checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 
 [[package]]
 name = "docker-update"
-version = "0.1.0"
+version = "1.0.2"
 dependencies = [
  "confy",
  "libc 1.0.0-alpha.4",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "docker-update"
-version = "0.1.0"
+version = "1.0.2"
 edition = "2024"
 authors = ['DragonSlayer_14']
 readme = "README.md"
@@ -24,7 +24,7 @@ maintainer = "DragonSlayer_14"
 copyright = "2026 Linuxapps"
 section = "utils"
 priority = "optional"
-depends = "$auto, sudo, docker.io | docker-ce"
+depends = "$auto, sudo, docker-ce-cli, docker-compose-plugin"
 extended-description = """\
 DockerUpdate durchsucht Verzeichnisse (standardmäßig in /var/apps) nach
 Docker-Compose-Dateien mit ':latest'-Images, prüft auf neuere Images,
@@ -43,3 +43,9 @@ assets = [
     { source = "LICENSE", dest = "/usr/share/licenses/docker-update/LICENSE", mode = "644", license = true },
 ]
 requires = { "sudo" = "*", "docker" = "*" }
+
+[package.metadata.arch]
+pkgrel = "1"
+arch = "x86_64"
+depends = ["gcc-libs", "glibc", "sudo", "docker-ce-cli", "docker-compose-plugin"]
+optdepends = ["docker-compose: Unterstützung für Docker Compose v1"]

README.md

@@ -29,7 +29,7 @@ auf neuere Versionen prüft, aktualisiert und neu startet.
 
 ## Voraussetzungen
 
-- **Betriebssystem**: Linux (x86_64, aarch64)
+- **Betriebssystem**: Linux (amd64 / x86_64, arm64 / aarch64, i386 / i686)
 - **Laufzeit-Abhängigkeiten**:
     - `docker` (inkl. Docker Compose Plugin `docker compose` oder Standalone `docker-compose`)
     - `sudo`
@@ -40,7 +40,7 @@ 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 /
+Über die CI/CD-Pipelines werden bei jedem Push auf den `main`-Branch (Release / Stable) und `testing`-Branch (Preview /
 Testing) automatisch Pakete für **Debian/Ubuntu**, **Fedora/RHEL** und **Arch Linux** in der Gitea-Paket-Registry
 bereitgestellt.
 
@@ -61,7 +61,7 @@ sudo apt update
 sudo apt install docker-update
 ```
 
-#### Testing (Vorschau / Dev)
+#### Testing (Vorschau / Testing)
 
 ```bash
 # Keyring installieren
@@ -76,50 +76,88 @@ sudo apt install docker-update
 
 ---
 
-### 2. Fedora / RHEL / CentOS (`dnf` / `yum`)
+### 2. RedHat / Fedora / SUSE
 
 #### Stable (Produktiv)
 
-Erstelle die Repository-Datei `/etc/yum.repos.d/docker-update.repo`:
+Repository einrichten:
-
 ```bash
-sudo tee /etc/yum.repos.d/docker-update-stable.repo << 'EOF'
+# auf RedHat-basierten Distributionen
-[docker-update-stable]
+dnf config-manager --add-repo https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/stable.repo
-name=DockerUpdate Stable
-baseurl=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/stable
-enabled=1
-gpgcheck=0
-EOF
 
-# Installation via DNF
+# Fedora 41+ (DNF5)
-sudo dnf install docker-update
+dnf config-manager addrepo --from-repofile=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/stable.repo
+
+# auf SUSE-basierten Distributionen
+zypper addrepo https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/stable.repo
 ```
 
-#### Testing (Vorschau / Dev)
+Paket installieren:
 
 ```bash
-sudo tee /etc/yum.repos.d/docker-update-testing.repo << 'EOF'
+# auf RedHat-basierten Distributionen
-[docker-update-testing]
+dnf install docker-update
-name=DockerUpdate Testing
-baseurl=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/testing
-enabled=1
-gpgcheck=0
-EOF
 
-# Installation via DNF
+# auf SUSE-basierten Distributionen
-sudo dnf install docker-update
+zypper install docker-update
+```
+
+#### Testing (Vorschau / Testing)
+
+Repository einrichten:
+```bash
+# auf RedHat-basierten Distributionen
+dnf config-manager --add-repo https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/testing.repo
+
+# Fedora 41+ (DNF5)
+dnf config-manager addrepo --from-repofile=https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/testing.repo
+
+# auf SUSE-basierten Distributionen
+zypper addrepo https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/rpm/testing.repo
+```
+
+Paket installieren:
+
+```bash
+# auf RedHat-basierten Distributionen
+dnf install docker-update
+
+# auf SUSE-basierten Distributionen
+zypper install docker-update
 ```
 
 ---
 
 ### 3. Arch Linux (`pacman`)
 
+### Installiere den GPG-Key für das Repository
+
+Key herunterladen:
+
+```bash
+wget https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/arch/repository.key
+```
+
+ID des Keys anzeigen lassen:
+
+```bash
+gpg --show-keys repository.key
+```
+
+Key zu pacman hinzufügen und signieren:
+
+```
+pacman-key --add repository.key
+pacman-key --lsign-key {key id}
+```
+
+{key id} = ID aus dem vorherigen Schritt
+
 #### Stable (Produktiv)
 
 Füge das Repository in `/etc/pacman.conf` ein:
-
 ```ini
-[docker-update-stable]
+[stable]
 SigLevel = Optional TrustAll
 Server = https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/arch/stable/$arch
 ```
@@ -130,12 +168,12 @@ Installiere das Paket anschließend:
 sudo pacman -Sy docker-update
 ```
 
-#### Testing (Vorschau / Dev)
+#### Testing (Vorschau / Testing)
 
 Füge das Testing-Repository in `/etc/pacman.conf` ein:
 
 ```ini
-[docker-update-testing]
+[testing]
 SigLevel = Optional TrustAll
 Server = https://gitea.creative-dragonslayer.de/api/packages/Linuxapps/arch/testing/$arch
 ```
@@ -218,7 +256,7 @@ cargo install cargo-deb
 cargo deb
 
 # Installation des erstellten Pakets
-sudo dpkg -i target/debian/docker-update_0.1.0-1_amd64.deb
+sudo dpkg -i target/debian/docker-update_*.deb
 ```
 
 Die Paketkonfiguration und Abhängigkeiten (`sudo`, `docker.io | docker-ce`) sind in `Cargo.toml` unter
@@ -226,49 +264,49 @@ Die Paketkonfiguration und Abhängigkeiten (`sudo`, `docker.io | docker-ce`) sin
 
 ---
 
-### 2. Arch Linux (`PKGBUILD`)
+### 2. Arch Linux (`.pkg.tar.zst`)
 
-Für Arch Linux liegt ein `PKGBUILD` im Verzeichnis `packaging/arch/` bereit:
+Die Paketmetadaten und Abhängigkeiten für Arch Linux sind direkt in `Cargo.toml` unter `[package.metadata.arch]`
+hinterlegt. Das Paket kann nach dem Kompilieren des Release-Builds über das Skript `scripts/package-arch.py` (analog zu
+CI/CD) erzeugt werden (optional mit `--target <TRIPLE>` für Cross-Builds):
 
 ```bash
-cd packaging/arch
+# Release kompilieren
+cargo build --release
 
-# Paket bauen und installieren
+# Arch Linux-Paket (.pkg.tar.zst) erstellen (Standard: Host/x86_64)
-makepkg -si
+python3 scripts/package-arch.py
+
+# Optional für spezifische Zielarchitektur:
+# python3 scripts/package-arch.py --target aarch64-unknown-linux-gnu
+# python3 scripts/package-arch.py --target i686-unknown-linux-gnu
+
+# Installation des erstellten Pakets
+sudo pacman -U target/arch/docker-update-*.pkg.tar.zst
 ```
 
-Alternativ kann das Binary auch manuell mit `pacman -U <paketdatei>.pkg.tar.zst` installiert werden.
-
 ---
 
 ### 3. Fedora / RHEL / CentOS (`.rpm`)
 
-Für RPM-basierte Distributionen gibt es zwei Möglichkeiten:
+Das RPM-Paket wird mithilfe von [`cargo-generate-rpm`](https://github.com/cat-in-136/cargo-generate-rpm) direkt aus den
-
+Metadaten in `Cargo.toml` (`[package.metadata.generate-rpm]`) erstellt:
-#### Option A: Mit `cargo-generate-rpm`
 
 ```bash
-# cargo-generate-rpm installieren
+# cargo-generate-rpm installieren (falls noch nicht vorhanden)
 cargo install cargo-generate-rpm
 
 # Release bauen und RPM erzeugen
 cargo build --release
 cargo generate-rpm
 
+# Optional für spezifische Zielarchitektur (z.B. Cross-Builds):
+# mkdir -p target/generate-rpm
+# cargo generate-rpm --target aarch64-unknown-linux-gnu -o target/generate-rpm
+# cargo generate-rpm --target i686-unknown-linux-gnu -o target/generate-rpm
+
 # Installation des erstellten RPM-Pakets
-sudo dnf install target/generate-rpm/docker-update-0.1.0-1.*.rpm
+sudo dnf install target/generate-rpm/docker-update-*.rpm
-```
-
-#### Option B: Mit `rpmbuild` und Spec-Datei
-
-Die RPM-Spec-Datei befindet sich in `packaging/fedora/docker-update.spec`:
-
-```bash
-# Erforderliche Build-Werkzeuge installieren
-sudo dnf install rpm-build
-
-# Paket über rpmbuild erstellen
-rpmbuild -ba packaging/fedora/docker-update.spec
 ```
 
 ---

packaging/arch/PKGBUILD

@@ -1,40 +0,0 @@
-# Maintainer: DragonSlayer_14
-
-pkgname=docker-update
-pkgver=0.1.0
-pkgrel=1
-pkgdesc="Automatisches Aktualisieren von Docker-Compose-Anwendungen in /var/apps mit :latest-Images"
-arch=('x86_64' 'aarch64')
-url="https://gitea.creative-dragonslayer.de/Linuxapps/DockerUpdate"
-license=('GPL-3.0-or-later')
-depends=('gcc-libs' 'glibc' 'sudo' 'docker')
-optdepends=('docker-compose: Unterstützung für Docker Compose v1')
-makedepends=('cargo')
-source=("$pkgname-$pkgver.tar.gz::$url/archive/v$pkgver.tar.gz")
-sha256sums=('SKIP')
-
-prepare() {
-    cd "$srcdir/$pkgname-$pkgver" 2>/dev/null || cd "$srcdir/$pkgname" 2>/dev/null || cd "$srcdir"
-    export RUSTUP_TOOLCHAIN=stable
-    cargo fetch --locked --target "$(rustc -vV | sed -n 's/host: //p')" 2>/dev/null || cargo fetch || true
-}
-
-build() {
-    cd "$srcdir/$pkgname-$pkgver" 2>/dev/null || cd "$srcdir/$pkgname" 2>/dev/null || cd "$srcdir"
-    export RUSTUP_TOOLCHAIN=stable
-    export CARGO_TARGET_DIR=target
-    cargo build --frozen --release --all-targets 2>/dev/null || cargo build --release
-}
-
-check() {
-    cd "$srcdir/$pkgname-$pkgver" 2>/dev/null || cd "$srcdir/$pkgname" 2>/dev/null || cd "$srcdir"
-    export RUSTUP_TOOLCHAIN=stable
-    cargo test --frozen 2>/dev/null || cargo test
-}
-
-package() {
-    cd "$srcdir/$pkgname-$pkgver" 2>/dev/null || cd "$srcdir/$pkgname" 2>/dev/null || cd "$srcdir"
-    install -Dm755 "target/release/$pkgname" "$pkgdir/usr/bin/$pkgname"
-    install -Dm644 "LICENSE" "$pkgdir/usr/share/licenses/$pkgname/LICENSE"
-    install -Dm644 "README.md" "$pkgdir/usr/share/doc/$pkgname/README.md"
-}

packaging/arch/build-package.sh

@@ -1,54 +0,0 @@
-#!/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 <<EOF > "$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"

packaging/fedora/docker-update.spec

@@ -1,42 +0,0 @@
-Name:           docker-update
-Version:        0.1.0
-Release:        1%{?dist}
-Summary:        Automatisches Aktualisieren von Docker-Compose-Anwendungen in /var/apps mit :latest-Images
-
-License:        GPL-3.0-or-later
-URL:            https://gitea.creative-dragonslayer.de/Linuxapps/DockerUpdate
-Source0:        %{name}-%{version}.tar.gz
-
-BuildRequires:  cargo
-BuildRequires:  rust
-Requires:       sudo
-Requires:       (docker or moby-engine or docker-ce)
-Suggests:       (docker-compose or docker-compose-plugin)
-
-%description
-DockerUpdate durchsucht Verzeichnisse (standardmäßig in /var/apps) nach
-Docker-Compose-Dateien mit ':latest'-Images, prüft auf neuere Images,
-lädt diese herunter und startet die betroffenen Container automatisch neu.
-
-%prep
-%autosetup
-
-%build
-cargo build --release
-
-%check
-cargo test
-
-%install
-install -D -p -m 0755 target/release/%{name} %{buildroot}%{_bindir}/%{name}
-install -D -p -m 0644 README.md %{buildroot}%{_docdir}/%{name}/README.md
-install -D -p -m 0644 LICENSE %{buildroot}%{_licensedir}/%{name}/LICENSE
-
-%files
-%license LICENSE
-%doc README.md
-%{_bindir}/%{name}
-
-%changelog
-* Sun Aug 23 2026 DragonSlayer_14 <dragonslayer@creative-dragonslayer.de> - 0.1.0-1
-- Erstveröffentlichung von docker-update

scripts/package-arch.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import os
+import subprocess
+import tempfile
+import time
+
+TARGET_ARCH_MAP = {
+    "x86_64-unknown-linux-gnu": "x86_64",
+    "x86_64-unknown-linux-musl": "x86_64",
+    "x86_64": "x86_64",
+    "amd64": "x86_64",
+    "aarch64-unknown-linux-gnu": "aarch64",
+    "aarch64-unknown-linux-musl": "aarch64",
+    "aarch64": "aarch64",
+    "arm64": "aarch64",
+    "i686-unknown-linux-gnu": "i686",
+    "i686-unknown-linux-musl": "i686",
+    "i686": "i686",
+    "i386": "i686",
+}
+
+
+def build_package(target_triple=None, target_arch=None):
+    metadata = json.loads(subprocess.check_output(["cargo", "metadata", "--format-version", "1", "--no-deps"]))
+    pkg = metadata["packages"][0]
+    name = pkg["name"]
+    version = pkg["version"]
+    description = pkg.get("description", "")
+    license_name = pkg.get("license", "")
+    repository = pkg.get("repository", "")
+    authors = pkg.get("authors", [])
+    author = authors[0] if authors else "Unknown"
+
+    arch_meta = pkg.get("metadata", {}).get("arch", {})
+    pkgrel = arch_meta.get("pkgrel", "1")
+    default_arch = arch_meta.get("arch", "x86_64")
+
+    if target_arch:
+        arch = TARGET_ARCH_MAP.get(target_arch, target_arch)
+    elif target_triple:
+        arch = TARGET_ARCH_MAP.get(target_triple, default_arch)
+    else:
+        arch = default_arch
+
+    candidate_paths = []
+    if target_triple:
+        candidate_paths.append(f"target/{target_triple}/release/{name}")
+    candidate_paths.append(f"target/release/{name}")
+
+    bin_path = None
+    for p in candidate_paths:
+        if os.path.exists(p):
+            bin_path = p
+            break
+
+    if not bin_path:
+        raise FileNotFoundError(
+            f"Keine kompilierte Binary für {name} gefunden. Gesuchte Pfade: {candidate_paths}"
+        )
+
+    depends = arch_meta.get("depends", ["gcc-libs", "glibc", "sudo", "docker-ce-cli", "docker-compose-plugin"])
+    optdepends = arch_meta.get("optdepends", ["docker-compose: Unterstützung für Docker Compose v1"])
+
+    with tempfile.TemporaryDirectory() as build_dir:
+        bin_dir = os.path.join(build_dir, "usr/bin")
+        doc_dir = os.path.join(build_dir, f"usr/share/doc/{name}")
+        lic_dir = os.path.join(build_dir, f"usr/share/licenses/{name}")
+        os.makedirs(bin_dir, exist_ok=True)
+        os.makedirs(doc_dir, exist_ok=True)
+        os.makedirs(lic_dir, exist_ok=True)
+
+        subprocess.run(["install", "-m", "755", bin_path, f"{bin_dir}/{name}"], check=True)
+        if os.path.exists("LICENSE"):
+            subprocess.run(["install", "-m", "644", "LICENSE", f"{lic_dir}/LICENSE"], check=True)
+        if os.path.exists("README.md"):
+            subprocess.run(["install", "-m", "644", "README.md", f"{doc_dir}/README.md"], check=True)
+
+        installed_size = subprocess.check_output(["du", "-sb", build_dir]).decode().split()[0]
+        builddate = str(int(time.time()))
+
+        pkginfo_lines = [
+            f"pkgname = {name}",
+            f"pkgbase = {name}",
+            f"pkgver = {version}-{pkgrel}",
+            f"pkgdesc = {description}",
+            f"url = {repository}",
+            f"builddate = {builddate}",
+            f"packager = {author}",
+            f"size = {installed_size}",
+            f"arch = {arch}",
+            f"license = {license_name}",
+        ]
+        for dep in depends:
+            pkginfo_lines.append(f"depend = {dep}")
+        for optdep in optdepends:
+            pkginfo_lines.append(f"optdepend = {optdep}")
+        pkginfo_lines.append("makepkgopt = strip\n")
+
+        with open(os.path.join(build_dir, ".PKGINFO"), "w") as f:
+            f.write("\n".join(pkginfo_lines))
+
+        os.makedirs("target/arch", exist_ok=True)
+        output_file = os.path.abspath(f"target/arch/{name}-{version}-{pkgrel}-{arch}.pkg.tar.zst")
+        subprocess.run(["tar", "--zstd", "-cf", output_file, ".PKGINFO", "usr"], cwd=build_dir, check=True)
+        print(f"Arch-Paket erfolgreich erstellt: {output_file}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Erstellt Arch Linux-Pakete (.pkg.tar.zst)")
+    parser.add_argument("--target", help="Rust Target-Triple (z.B. x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, i686-unknown-linux-gnu)")
+    parser.add_argument("--arch", help="Architektur (z.B. x86_64, aarch64, i686)")
+    args = parser.parse_args()
+
+    build_package(target_triple=args.target, target_arch=args.arch)
+
+
+if __name__ == "__main__":
+    main()

src/log.rs

@@ -1,10 +1,10 @@
 //! Einfaches, threadsicheres Logging-Modul.
 //!
 //! Merkmale:
-//! - Ausgabe in Terminal (stdout/stderr) und zusätzlich in eine Logdatei im temporären Verzeichnis.
+//! - Ausgabe auf Standard-Streams (stdout/stderr) und zusätzlich in eine Logdatei im temporären Verzeichnis.
 //! - Nachrichtenvorlage: `[DD.MM.YYYY HH:MM:SS.mmm][LEVEL][TAG]: <Text>` mit Präfix ([!]/[?]/[i]/[d]).
 //! - Der aktuell verwendete Schweregradfilter ist statisch (`LOG_LEVEL`) und wird zur Laufzeit nicht geändert.
-//! - Terminal-Erkennung und Dateihandle werden lazily initialisiert und zwischengespeichert (`OnceLock`).
+//! - Dateihandle wird lazily initialisiert und zwischengespeichert (`OnceLock`).
 //!
 //! Hinweise:
 //! - Bei einem leeren `tag` wird ein leerer Tag-Abschnitt erzeugt.
@@ -22,13 +22,13 @@
 
 use std::env;
 use std::fmt::{Display, Formatter};
-use std::fs::{create_dir_all, File, OpenOptions};
+use std::fs::{File, OpenOptions, create_dir_all};
-use std::io::{stdout, IsTerminal, Write};
+use std::io::Write;
 use std::sync::{Mutex, OnceLock};
 
 use crate::config;
 use crate::program;
-use time::{macros::format_description, OffsetDateTime};
+use time::{OffsetDateTime, macros::format_description};
 
 /// Schweregrade für Logeinträge in aufsteigender Detailtiefe.
 ///
@@ -71,14 +71,11 @@ impl TryFrom<String> for LogLevel {
             "warn" => Ok(LogLevel::Warn),
             "info" => Ok(LogLevel::Info),
             "debug" => Ok(LogLevel::Debug),
-            _ => Err(LogLevel::Info)
+            _ => Err(LogLevel::Info),
         }
     }
 }
 
-/// Zwischenspeicher für die einmalig ermittelte Terminal-Fähigkeit von `stdout`.
-static IS_TERMINAL: OnceLock<bool> = OnceLock::new();
-
 /// Globaler Schweregradfilter für Ausgabe.
 static LOG_LEVEL: OnceLock<LogLevel> = OnceLock::new();
 
@@ -89,7 +86,7 @@ static LOG_FILE: OnceLock<Mutex<Option<File>>> = OnceLock::new();
 ///
 /// Verhalten:
 /// - Wenn `log_level` größer als der globale Filter ist, wird nichts ausgegeben.
-/// - Bei Terminalausgabe gehen `Error`-Meldungen nach `stderr`, alle anderen nach `stdout`.
+/// - `Error`-Meldungen gehen nach `stderr`, alle anderen nach `stdout`.
 /// - Zusätzlich wird in eine tägliche Logdatei im Temp-Verzeichnis geschrieben (wenn erfolgreich geöffnet).
 ///
 /// Parameter:
@@ -109,12 +106,10 @@ pub fn log(tag: &str, message: &str, log_level: LogLevel) {
     if log_level <= get_log_level() {
         let message: String = format_message(tag, message, &log_level);
 
-        if is_terminal() {
+        if log_level == LogLevel::Error {
-            if log_level == LogLevel::Error {
+            eprintln!("{}", message);
-                eprintln!("{}", message)
+        } else {
-            } else {
+            println!("{}", message);
-                println!("{}", message)
-            }
         }
 
         let file_lock = get_or_init_log_file();
@@ -138,17 +133,7 @@ fn get_log_level() -> LogLevel {
     *LOG_LEVEL.get_or_init(|| {
         let log_level = &config::get_config().general.log_level;
         LogLevel::try_from(log_level.to_string()).unwrap_or(LogLevel::Info)
-    }
+    })
-    )
-}
-
-/// Ermittelt einmalig, ob `stdout` ein Terminal ist, und cached das Ergebnis.
-///
-/// Rückgabe:
-/// - `true`, wenn `stdout` ein TTY/Terminal ist.
-/// - `false` andernfalls.
-fn is_terminal() -> bool {
-    *IS_TERMINAL.get_or_init(|| stdout().is_terminal())
 }
 
 /// Formatiert eine Lognachricht mit Zeitstempel, Level, Tag und Präfix.
@@ -234,10 +219,7 @@ fn open_log_file() -> std::io::Result<File> {
     let file_name = format!("log-{}.log", date_str);
     dir.push(file_name);
 
-    OpenOptions::new()
+    OpenOptions::new().create(true).append(true).open(dir)
-        .create(true)
-        .append(true)
-        .open(dir)
 }
 
 #[cfg(test)]

src/sudo.rs

@@ -1,6 +1,7 @@
+use crate::log::{LogLevel, log};
 use std::env;
 use std::os::unix::process::CommandExt;
-use std::process::Command;
+use std::process::{Command, exit};
 
 /// Prüft, ob das Programm mit Root-/Administrator-Rechten ausgeführt wird.
 ///
@@ -11,10 +12,17 @@ use std::process::Command;
 pub fn is_run_as_root() -> bool {
     unsafe { libc::geteuid() == 0 }
 }
+
 /// Startet das Programm mit Root-Rechten über `sudo` neu.
 ///
 /// Diese Funktion versucht das Programm mit erhöhten Rechten neu zu starten.
 pub fn run_as_root() {
     let commandline_args: Vec<String> = env::args().collect();
-    let _output = Command::new("sudo").args(&commandline_args).exec(); // Bye bye never returns
+    let err = Command::new("sudo").args(&commandline_args).exec();
+    log(
+        "auth",
+        &format!("Fehler beim Ausführen von 'sudo': {}", err),
+        LogLevel::Error,
+    );
+    exit(1);
 }

src/updater.rs

@@ -93,7 +93,7 @@ fn run_docker_command(args: &[&str]) -> std::io::Result<Output> {
 }
 
 /// Führt einen Docker-Compose-Befehl im angegebenen Verzeichnis aus.
-/// Versucht zuerst `docker compose` und fällt bei Bedarf auf `docker-compose` zurück.
+/// Versucht zuerst `docker compose` und fällt bei Nichtverfügbarkeit auf `docker-compose` zurück.
 pub fn run_compose_command(dir: &Path, args: &[&str]) -> std::io::Result<Output> {
     let mut compose_args = vec!["compose"];
     compose_args.extend_from_slice(args);
@@ -104,14 +104,32 @@ pub fn run_compose_command(dir: &Path, args: &[&str]) -> std::io::Result<Output>
         .output();
 
     match output {
-        Ok(out) if out.status.success() || out.status.code() != Some(127) => Ok(out),
+        Ok(out) => {
-        _ => {
+            let stderr = String::from_utf8_lossy(&out.stderr);
-            // Fallback auf docker-compose (v1)
+            let is_unavailable = !out.status.success()
+                && (stderr.contains("is not a docker command")
+                    || stderr.contains("unknown command \"compose\"")
+                    || stderr.contains("unknown command: compose"));
+
+            if is_unavailable {
+                if let Ok(fallback_out) = Command::new("docker-compose")
+                    .current_dir(dir)
+                    .args(args)
+                    .output()
+                {
+                    return Ok(fallback_out);
+                }
+            }
+            Ok(out)
+        }
+        Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
+            // docker-Binary nicht gefunden, versuche docker-compose
             Command::new("docker-compose")
                 .current_dir(dir)
                 .args(args)
                 .output()
         }
+        Err(err) => Err(err),
     }
 }