astrapi-backup 26.4.6__tar.gz

astrapi_backup-26.4.6/.claude-memory.md

@@ -0,0 +1,121 @@
+# astrapi-backup – Claude Memory
+
+Projektkontext für Claude Code. Wird im Repo versioniert, damit es auf jedem PC verfügbar ist.
+
+---
+
+## Was ist astrapi-backup?
+
+Web-UI zur zentralen Verwaltung von Backup-Jobs (Borg, Rsync, Proxmox, Remote-Geräte).
+Basiert auf **astrapi-core** (FastAPI + Flask + HTMX + Jinja2).
+PyPI-Paketname: `astrapi-backup`, Python-Paket: `astrapi_backup`.
+
+---
+
+## Stack
+
+| Komponente | Details |
+|---|---|
+| Framework | astrapi-core (FastAPI + HTMX) |
+| API | FastAPI (`/api/...`) |
+| UI | FastAPI + HTMX + Jinja2 (`/`) – kein Flask mehr! |
+| Persistenz | SQLite (über astrapi-core) |
+| Verschlüsselung | Fernet (Secrets via astrapi-core) |
+| Python | ≥ 3.11 |
+
+---
+
+## Verzeichnisstruktur
+
+```
+astrapi_backup/
+├── _app.py              # ASGI-App-Factory (uvicorn-Einstiegspunkt)
+├── _cli.py              # Console-Script: astrapi-backup
+├── _paths.py            # package_dir(), work_dir(), db_path(), log_dir()
+├── app.yaml             # name: astrapi-backup, display_name: Backup Control
+├── navigation.yaml      # App-Navigation (Borg, Rsync, Proxmox, Remotes)
+├── runner.py            # Job-Dispatcher
+├── api/
+│   ├── fastapi_app.py   # FastAPI-Factory, Run-Router-Registrierung
+│   ├── storage.py       # SQLite-Tabellen (borg, rsync, proxmox_*, remotes)
+│   ├── templates.py     # Jinja2-ChoiceLoader
+│   └── routers/
+│       └── run.py       # Generischer Run/Log/SSE-Router pro Modul
+├── modules/
+│   ├── borg/            # Borg-Backup-Modul
+│   ├── rsync/           # Rsync-Modul
+│   ├── proxmox_lxc/     # Proxmox LXC-Container
+│   ├── proxmox_hosts/   # Proxmox-Host-Backups
+│   ├── proxmox_jobs/    # Proxmox-Job-Verwaltung
+│   └── remotes/         # Remote-Geräte (WoL, SSH)
+└── overrides/
+    └── sysinfo.py       # App-spezifische Sysinfo-Konfiguration
+```
+
+---
+
+## App-Start
+
+```
+astrapi-backup --work-dir /opt/astrapi-backup --port 5001
+```
+
+- `_configure_paths("astrapi-backup")` setzt Runtime-Pfade
+- `configure_updater(_pkg)` registriert `astrapi-backup` + `astrapi-core` im Updater
+- Secrets-Key: `/var/lib/backupadm/secret.key` (Prod), `astrapi_backup/secret.key` (Dev)
+
+---
+
+## Template-Struktur (Modul-Konvention)
+
+```
+templates/
+├── content.html              # Vollständiger Modul-Inhalt (page-header + Listenbereich)
+├── partials/
+│   ├── card_body.html        # Card-Body-Snippet für list_wrapper_inner (content_template)
+│   ├── list_header.html      # Tabellen-Header-Spalten
+│   ├── list_row.html         # Tabellen-Zeilen-Spalten
+│   └── ...                   # Weitere kleine HTMX-Fragmente
+└── modals/
+    ├── edit.html             # Create/Edit-Dialog (falls modul-spezifisch)
+    ├── create.html           # Nur-Create-Dialog (z.B. proxmox_lxc, proxmox_jobs)
+    ├── log.html              # Log-Viewer
+    └── ...                   # Weitere modul-spezifische Dialoge
+```
+
+---
+
+## Modul-Konvention (Run-Module)
+
+Run-Module (borg, rsync, proxmox_lxc, proxmox_hosts, proxmox_jobs) haben zusätzlich:
+
+| Datei | Inhalt |
+|---|---|
+| `jobs.py` | `run_single(item_id)` – wird von `run.py` aufgerufen |
+| `api.py` | Zusätzliche FastAPI-Endpunkte (preview, archives, stats, …) |
+
+Run-Router: `POST /api/{module}/{item_id}/run`, `GET /api/{module}/{item_id}/logs`
+
+---
+
+## Datenbank
+
+Tabellen in `astrapi_backup/api/storage.py`: `borg`, `rsync`, `proxmox_lxc`, `proxmox_hosts`, `proxmox_jobs`, `remotes`.
+YAML-Migration beim ersten Zugriff automatisch.
+
+---
+
+## Versionsschema
+
+CalVer: `YY.MM.patch.devN` – gesteuert via setuptools-scm + Git-Tags.
+
+---
+
+## Tests
+
+```
+pytest tests/unit/
+```
+
+- `conftest.py`: frische SQLite-DB je Test, isolierter Scheduler
+- `test_template_resolution.py`: prüft alle `TemplateResponse`-Referenzen auf Auflösbarkeit

astrapi_backup-26.4.6/.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # nötig für setuptools-scm
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build
+        run: |
+          pip install --quiet build
+          python -m build --wheel --sdist
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

astrapi_backup-26.4.6/.gitignore

@@ -0,0 +1,39 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+
+# Virtuelle Umgebungen
+.venv/
+venv/
+env/
+
+# Build & Distribution
+build/
+dist/
+*.zip
+
+# Tests & Coverage
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Laufzeitdaten (Dev: ./data/, ./logs/ – Prod: /var/lib/backupctl/)
+data/
+logs/
+
+# Logs
+*.log
+
+# Secrets
+.env
+.env.*
+*.key
+
+# IDE
+.idea/
+.vscode/
+
+# backupctl-spezifisch
+.borg/
+.release.env

astrapi_backup-26.4.6/.gitlab-ci.yml

@@ -0,0 +1,24 @@
+stages:
+  - publish
+
+publish:
+  stage: publish
+  image: python:3.12-slim
+  rules:
+    - if: '$CI_COMMIT_TAG =~ /^v/'
+  before_script:
+    - apt-get update -qq && apt-get install -y -qq git
+    - git fetch --tags
+  script:
+    - pip install --quiet build twine
+    - python -m build --wheel --sdist
+    - twine upload
+        --repository-url "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/pypi"
+        --username "__token__"
+        --password "$GITLAB_TOKEN_SECRET"
+        dist/*
+    - twine upload
+        --repository-url "https://gitlab.com/api/v4/projects/81004951/packages/pypi"
+        --username "__token__"
+        --password "$GITLAB_TOKEN_SECRET"
+        dist/*

astrapi_backup-26.4.6/CLAUDE.md

@@ -0,0 +1,3 @@
+# astrapi-backup
+
+@.claude-memory.md

astrapi_backup-26.4.6/PKG-INFO

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: astrapi-backup
+Version: 26.4.6
+Summary: Backup Control – Web-UI für Borg, Rsync, Proxmox
+Requires-Python: >=3.11
+Requires-Dist: fastapi>=0.115
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: jinja2>=3.1
+Requires-Dist: APScheduler>=3.10
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: cryptography>=42.0
+Requires-Dist: requests>=2.32
+Requires-Dist: urllib3>=2.2
+Requires-Dist: psutil>=6.0
+Requires-Dist: apispec>=6.0
+Requires-Dist: astrapi-core>=26.4.15
+Requires-Dist: borgbackup>=1.4.4

astrapi_backup-26.4.6/README.md

@@ -0,0 +1,80 @@
+# backupctl
+
+Web-UI zur zentralen Verwaltung von Backup-Jobs (Borg, Rsync, Proxmox, Remote-Geräte).
+
+## Dokumentation
+
+- Deutsche Benutzeranleitung: [Benutzeranleitung.md](Benutzeranleitung.md)
+
+## Voraussetzungen
+
+- Python >= 3.11
+- `astrapi-core` (lokales Repo, muss parallel geklont sein)
+
+### Systemabhängigkeiten
+
+```bash
+apt install borgbackup wakeonlan openssh-client
+```
+
+> Borg wird unter `/var/lib/backupadm/.venv/bin/borg` erwartet.
+
+## Setup nach dem Klonen
+
+1. Virtuelles Environment erstellen und aktivieren:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+```
+
+2. `astrapi-core` installieren (liegt als Schwesterprojekt neben diesem Repo):
+
+```bash
+pip install -e ../astrapi-core
+```
+
+3. `backupctl` selbst installieren:
+
+```bash
+pip install -e .
+```
+
+## Starten
+
+```bash
+backupctl --work-dir data --port 9999
+```
+
+**Mit Auto-Reload (Entwicklung):**
+
+```bash
+backupctl --work-dir data --port 9999 --reload
+```
+
+| Parameter    | Standard    | Beschreibung                            |
+|--------------|-------------|-----------------------------------------|
+| `--work-dir` | (Pflicht)   | Datenpfad für SQLite-DB und Laufzeitdaten |
+| `--port`     | `5001`      | HTTP-Port                               |
+| `--host`     | `0.0.0.0`   | Bind-Adresse                            |
+| `--reload`   | –           | Auto-Reload bei Dateiänderungen         |
+
+Die Web-Oberfläche ist danach erreichbar unter: `http://localhost:9999`
+
+## Projektstruktur
+
+```
+backupctl/
+├── _cli.py            # Einstiegspunkt (CLI)
+├── _app.py            # ASGI-App-Factory
+├── _paths.py          # Pfad-Utilities
+├── runner.py          # Job-Executor (Borg, Rsync, Proxmox)
+├── api/               # FastAPI-Router und SQLite-Backend
+└── modules/           # Feature-Module
+    ├── borg/
+    ├── rsync/
+    ├── proxmox_lxc/
+    ├── proxmox_hosts/
+    ├── proxmox_jobs/
+    └── remotes/
+```

astrapi_backup-26.4.6/astrapi_backup/__init__.py

@@ -0,0 +1 @@
+# astrapi_backup

astrapi_backup-26.4.6/astrapi_backup/_app.py

@@ -0,0 +1,63 @@
+"""astrapi_backup._app – ASGI-App-Factory.
+
+Wird von astrapi_backup._cli (Console-Script) und direkt von uvicorn importiert:
+    uvicorn astrapi_backup._app:app
+"""
+import time
+
+from astrapi_core.system.paths import configure as _configure_paths
+_configure_paths("astrapi-backup")
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from astrapi_core.ui import create as create_ui
+from astrapi_core.ui.module_registry import load_modules
+from astrapi_core.ui.settings_registry import init as settings_init
+from astrapi_core.system.health import register_health
+from astrapi_core.system.systemd import sd_notify, start_watchdog
+from astrapi_core.system.version import get_display_name
+from astrapi_core.modules.settings.engine import configure as configure_settings
+from astrapi_core.modules.system.updater import configure as configure_updater
+
+from astrapi_backup._paths import package_dir, work_dir
+from astrapi_backup.api.fastapi_app import create as create_api
+
+_START_TIME = time.time()
+
+
+def _db_check() -> tuple[bool, dict]:
+    from astrapi_core.system.db import _conn
+    try:
+        _conn().execute("SELECT 1").fetchone()
+        return True, {"db": True}
+    except Exception:
+        return False, {"db": False}
+
+
+def create_app() -> FastAPI:
+    _pkg = package_dir()
+    configure_settings(health_fn=_db_check, app_name=get_display_name(_pkg))
+    configure_updater(_pkg)
+
+    from astrapi_backup.api.storage import init_db
+    init_db()
+
+    settings_init(work_dir())
+    modules, _ = load_modules(_pkg)
+    api = create_api(modules=modules)
+
+    import astrapi_core.ui
+    from pathlib import Path
+    core_static = Path(astrapi_core.ui.__file__).parent / "static"
+    api.mount("/static", StaticFiles(directory=str(core_static)), name="static")
+
+    create_ui(api, app_root=_pkg, modules=modules)
+
+    register_health(api, check_fn=_db_check, start_time=_START_TIME)
+    start_watchdog(check_fn=lambda: _db_check()[0])
+    sd_notify("READY=1")
+    return api
+
+
+app = create_app()

astrapi_backup-26.4.6/astrapi_backup/_cli.py

@@ -0,0 +1,15 @@
+"""astrapi_backup._cli – Console-Script-Einstiegspunkt.
+
+Start:
+    astrapi-backup --work-dir /opt/astrapi-backup --port 5001
+    astrapi-backup --work-dir /opt/astrapi-backup --port 5001 --debug    # Debug-Modus (inkl. reload)
+"""
+from astrapi_core.system.paths import run_app
+
+
+def main() -> None:
+    run_app("astrapi_backup._app:app", "astrapi-backup", default_port=5001)
+
+
+if __name__ == "__main__":
+    main()

astrapi_backup-26.4.6/astrapi_backup/_paths.py

@@ -0,0 +1,9 @@
+# astrapi_backup/_paths.py
+from pathlib import Path
+
+from astrapi_core.system.paths import work_dir, db_path, log_dir  # noqa: F401 – re-export
+
+
+def package_dir() -> Path:
+    """Pfad zum installierten Package – für app.yaml, Templates, Modul-YAMLs."""
+    return Path(__file__).resolve().parent

astrapi_backup-26.4.6/astrapi_backup/api/fastapi_app.py

@@ -0,0 +1,48 @@
+"""astrapi_backup.api.fastapi_app – FastAPI-Factory."""
+from pathlib import Path
+from fastapi import FastAPI
+from astrapi_core.system.version import get_app_version
+
+from astrapi_backup._paths import package_dir, log_dir
+
+APP_ROOT = package_dir()
+
+
+def create(modules: list | None = None) -> FastAPI:
+    """Erstellt die FastAPI-Anwendung.
+
+    modules: Vorgeladene Modulliste (z.B. aus _app.py). Wird nicht neu geladen
+             wenn angegeben – verhindert doppelten Modulaufruf.
+    """
+    _version = get_app_version(APP_ROOT, default="1.0.0")
+    app = FastAPI(
+        title="BackupCtl API",
+        version=_version,
+        docs_url="/api/docs",
+        redoc_url="/api/redoc",
+        openapi_url="/api/openapi.json",
+    )
+
+    from astrapi_core.system.logger import configure_log_root
+    configure_log_root(log_dir())
+
+    from astrapi_core.system.secrets import configure as configure_secrets
+    configure_secrets(
+        key_path     = Path("/var/lib/backupadm/secret.key"),
+        dev_key_path = package_dir() / "secret.key",
+    )
+
+    # ── Modul-Router registrieren (nur laden wenn nicht übergeben) ────────────────────
+    from astrapi_core.ui.module_registry import load_modules, register_fastapi_modules
+    if modules is None:
+        modules, _ = load_modules(APP_ROOT)
+    register_fastapi_modules(app, modules)
+
+    # ── Run/Log-Router pro Modul (Framework-Standard: /api/{module}/{item}/run) ─
+    from astrapi_backup.api.routers.run import make_run_router
+    _RUN_MODULES = ["borg", "rsync", "proxmox_lxc", "proxmox_hosts", "proxmox_jobs"]
+    for _mod_key in _RUN_MODULES:
+        app.include_router(make_run_router(_mod_key), prefix=f"/api/{_mod_key}")
+        app.include_router(make_run_router(_mod_key), prefix=f"/ui/{_mod_key}")
+
+    return app