astrapi-backup 26.4.6__py3-none-any.whl

astrapi_backup/__init__.py

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

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/_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/_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/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

astrapi_backup/api/routers/run.py

@@ -0,0 +1,249 @@
+# api/routers/run.py
+import asyncio
+import json
+import threading
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import HTMLResponse, StreamingResponse
+
+from astrapi_core.system.logger import set_tee_context, clear_tee_context, set_active_log_id, clear_active_log_id
+from astrapi_core.system.activity_log import (
+    history_start, history_finish,
+    get_log_lines, get_latest_activity_log_id, list_runs_for_item,
+)
+from astrapi_backup.api.storage import load_config
+
+_templates = None
+
+
+def _get_templates():
+    global _templates
+    if _templates is None:
+        from astrapi_backup.api.templates import templates as t
+        _templates = t
+    return _templates
+
+
+_running: dict = {}
+_running_lock  = threading.Lock()
+
+
+def _is_running(module: str, item_id: str) -> bool:
+    return f"{module}:{item_id}" in _running
+
+def _mark_running(module: str, item_id: str, mode: str) -> None:
+    with _running_lock:
+        _running[f"{module}:{item_id}"] = mode
+
+def _mark_done(module: str, item_id: str) -> None:
+    with _running_lock:
+        _running.pop(f"{module}:{item_id}", None)
+
+def get_running() -> dict:
+    return dict(_running)
+
+
+def make_run_router(module: str, *, has_run_buttons: bool = True) -> APIRouter:
+    """Erzeugt einen APIRouter mit Run/Log-Routen für ein einzelnes Modul.
+
+    Einbinden mit prefix=f"/{module}" → externe URLs:
+      POST /api/{module}/{item_id}/run
+      POST /api/{module}/run
+      GET  /api/{module}/status
+      GET  /api/{module}/{item_id}/logs
+      GET  /api/{module}/{item_id}/logs/stream
+      GET  /api/{module}/{item_id}/logs/{log_id}
+    """
+    router = APIRouter(tags=[module])
+
+    # ── Status-Endpunkt für Badge-Refresh ────────────────────────────
+
+    @router.get("/status", response_class=HTMLResponse)
+    def module_status(request: Request):
+        from astrapi_core.ui.crud_blueprint import resolve_filters_for_request
+        cfg = load_config(module)
+        cfg, extra = resolve_filters_for_request(module, request, cfg)
+        return _get_templates().TemplateResponse(
+            request,
+            "partials/list_wrapper_inner.html",
+            {
+                "cfg": cfg, "module": module,
+                "container_id": f"tab-{module}", "loading_id": f"{module}-loading",
+                "content_template": f"{module}/partials/card_body.html",
+                "running": get_running(),
+                "has_run_buttons": has_run_buttons,
+                **extra,
+            },
+        )
+
+    # ── Einzelnen Eintrag ausführen ───────────────────────────────────
+
+    @router.post("/{item_id}/run", response_class=HTMLResponse)
+    def run_item(item_id: str, request: Request, debug: bool = False):
+        if _is_running(module, item_id):
+            raise HTTPException(status_code=409, detail="Läuft bereits")
+
+        _mark_running(module, item_id, "debug" if debug else "run")
+
+        log_id = f"{item_id}_debug" if debug else item_id
+
+        def _execute():
+            import time
+            desc    = _item_description(module, item_id)
+            hist_id = history_start(module, item_id, desc, "debug" if debug else "run")
+            t0      = time.time()
+            set_tee_context(module, log_id)
+            set_active_log_id(hist_id)
+            status = "ok"
+            try:
+                _dispatch_single(module, item_id)
+            except Exception:
+                status = "error"
+            finally:
+                duration = int(time.time() - t0)
+                # Status aus Log-Zeilen ableiten falls kein Exception-Fehler
+                if status == "ok":
+                    levels = {r["level"] for r in get_log_lines(hist_id)}
+                    if "ERROR" in levels:
+                        status = "error"
+                    elif "WARNING" in levels:
+                        status = "warning"
+                history_finish(hist_id, status, duration)
+                clear_active_log_id()
+                clear_tee_context()
+                _mark_done(module, item_id)
+                if not debug:
+                    from astrapi_core.modules.scheduler.job_runner import _notify
+                    _notify(module, desc, status, duration)
+
+        threading.Thread(target=_execute, daemon=True).start()
+
+        from astrapi_core.ui.crud_blueprint import resolve_filters_for_request
+        cfg = load_config(module)
+        cfg, extra = resolve_filters_for_request(module, request, cfg)
+        list_html = _get_templates().TemplateResponse(
+            request,
+            "partials/list_wrapper_inner.html",
+            {
+                "cfg": cfg, "module": module,
+                "container_id": f"tab-{module}", "loading_id": f"{module}-loading",
+                "content_template": f"{module}/partials/card_body.html",
+                "running": get_running(),
+                "has_run_buttons": has_run_buttons,
+                **extra,
+            },
+        ).body.decode()
+
+        trigger = json.dumps({"openLogModal": {"module": module, "itemId": log_id}})
+        return HTMLResponse(list_html, headers={"HX-Trigger": trigger})
+
+    # ── SSE: Live-Log-Stream (DB-basiert) ─────────────────────────────
+
+    @router.get("/{item_id}/logs/stream")
+    async def stream_log_ep(item_id: str):
+        async def event_generator():
+
+            # Warte bis activity_log-Eintrag existiert (Job startet im Thread)
+            act_log_id = None
+            waited     = 0.0
+            while act_log_id is None and waited < 15:
+                act_log_id = get_latest_activity_log_id(module, item_id)
+                if act_log_id is None:
+                    await asyncio.sleep(0.3)
+                    waited += 0.3
+
+            if act_log_id is None:
+                yield "event: done\ndata: \n\n"
+                return
+
+            last_id        = 0
+            idle_after_done = 0.0
+
+            while True:
+                rows = get_log_lines(act_log_id, after_id=last_id)
+                for row in rows:
+                    last_id = row["id"]
+                    level   = row["level"].lower()
+                    safe    = (row["line"]
+                               .replace("&", "&amp;")
+                               .replace("<", "&lt;")
+                               .replace(">", "&gt;"))
+                    yield f"data: <div class=\"log-line log-{level}\">{safe}</div>\n\n"
+
+                running_key  = item_id.removesuffix("_debug") if item_id.endswith("_debug") else item_id
+                still_running = _is_running(module, running_key) or _is_running(module, item_id)
+
+                if not still_running:
+                    idle_after_done += 0.5
+                    if idle_after_done >= 3:
+                        yield "event: done\ndata: \n\n"
+                        return
+                else:
+                    idle_after_done = 0.0
+
+                await asyncio.sleep(0.5)
+
+        return StreamingResponse(
+            event_generator(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    # ── Log-Endpunkte (DB-basiert) ────────────────────────────────────
+
+    @router.get("/{item_id}/logs", response_class=HTMLResponse)
+    def get_logs(item_id: str, request: Request, live: int = 0):
+        runs       = list_runs_for_item(module, item_id)
+        act_log_id = runs[0]["id"] if runs else None
+        lines      = [r["line"] for r in get_log_lines(act_log_id)] if act_log_id else []
+
+        # "dates" = Liste von Runs für den Datum-Wähler im Modal
+        dates    = [{"id": str(r["id"]), "label": r["started_at"] or str(r["id"])} for r in runs]
+        selected = str(act_log_id) if act_log_id else None
+
+        return _get_templates().TemplateResponse(
+            request,
+            "partials/log_modal.html",
+            {
+                "module": module, "item_id": item_id,
+                "description": _item_description(module, item_id),
+                "dates": dates, "selected": selected, "lines": lines,
+                "live": bool(live),
+            },
+        )
+
+    @router.get("/{item_id}/logs/{log_id}", response_class=HTMLResponse)
+    def get_log_by_id(item_id: str, log_id: str, request: Request):
+        lines = [r["line"] for r in get_log_lines(int(log_id))] if log_id.isdigit() else []
+        return _get_templates().TemplateResponse(
+            request,
+            "partials/log_content.html",
+            {"lines": lines, "date": log_id},
+        )
+
+    return router
+
+
+# ── Hilfsfunktionen ───────────────────────────────────────────────
+
+def _item_description(module: str, item_id: str) -> str:
+    debug = item_id.endswith("_debug")
+    base  = item_id.removesuffix("_debug")
+    try:
+        cfg = load_config(module)
+        raw = cfg.get(base) or cfg.get(int(base) if base.isdigit() else base) or {}
+        desc = raw.get("description") or raw.get("job") or raw.get("host") or raw.get("source_path") or base
+        return f"{desc} (Debug)" if debug else desc
+    except Exception:
+        return item_id
+
+
+def _dispatch_single(module: str, item_id: str) -> None:
+    import importlib
+    try:
+        mod = importlib.import_module(f"astrapi_backup.modules.{module}.jobs")
+    except ModuleNotFoundError:
+        from astrapi_core.system.logger import log
+        log("ERROR", f"Unbekanntes Modul: {module}")
+        return
+    mod.run_single(item_id)

astrapi_backup/api/storage.py

@@ -0,0 +1,129 @@
+# api/storage.py
+"""SQLite-Backend mit einer Tabelle pro Modul."""
+
+from astrapi_core.system.db import (
+    configure as _configure_db,
+    register_table, create_all_registered_tables,
+    load_config, get_item, save_item, delete_item, next_item_id, get_entry, patch_item,
+)
+from astrapi_core.system.activity_log import (
+    log_activity, update_activity_log,
+    list_activity, get_activity_log, clear_activity_log,
+    get_latest_activity_log_id, list_runs_for_item,
+    history_start, history_finish, list_history,
+    append_log_line, get_log_lines,
+)
+
+from astrapi_backup._paths import db_path as _db_path
+
+DB_PATH = _db_path()
+
+
+# ── App-Tabellen-Konfiguration ─────────────────────────────────────
+
+_APP_TABLES = {
+    "borg": {
+        "ddl": """
+            CREATE TABLE IF NOT EXISTS borg (
+                id               INTEGER PRIMARY KEY AUTOINCREMENT,
+                enabled          INTEGER NOT NULL DEFAULT 1,
+                description      TEXT    NOT NULL DEFAULT '',
+                source_remote_id TEXT,
+                source_path      TEXT    NOT NULL DEFAULT '',
+                target_remote_id TEXT,
+                target_path      TEXT    NOT NULL DEFAULT '',
+                pre_hooks        TEXT,
+                post_hooks       TEXT,
+                exclude          TEXT,
+                last_run         TEXT,
+                last_status      TEXT
+            )""",
+        "list_fields": ["pre_hooks", "post_hooks", "exclude"],
+        "col_in":  {"pre_hooks": "pre", "post_hooks": "post"},
+        "col_out": {"pre": "pre_hooks", "post": "post_hooks"},
+    },
+
+    "rsync": {
+        "ddl": """
+            CREATE TABLE IF NOT EXISTS rsync (
+                id               INTEGER PRIMARY KEY AUTOINCREMENT,
+                enabled          INTEGER NOT NULL DEFAULT 1,
+                description      TEXT    NOT NULL DEFAULT '',
+                type             TEXT    NOT NULL DEFAULT '',
+                source_remote_id TEXT,
+                source_path      TEXT    NOT NULL DEFAULT '',
+                target_remote_id TEXT,
+                target_path      TEXT    NOT NULL DEFAULT '',
+                last_run         TEXT,
+                last_status      TEXT
+            )""",
+    },
+
+    "proxmox_lxc": {
+        "ddl": """
+            CREATE TABLE IF NOT EXISTS proxmox_lxc (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                vmid        INTEGER NOT NULL,
+                description TEXT    NOT NULL DEFAULT '',
+                node        TEXT    NOT NULL DEFAULT '',
+                enabled     INTEGER NOT NULL DEFAULT 1,
+                last_run    TEXT,
+                last_status TEXT
+            )""",
+    },
+
+    "proxmox_hosts": {
+        "ddl": """
+            CREATE TABLE IF NOT EXISTS proxmox_hosts (
+                id            INTEGER PRIMARY KEY AUTOINCREMENT,
+                description   TEXT    NOT NULL DEFAULT '',
+                enabled       INTEGER NOT NULL DEFAULT 1,
+                remote_id     TEXT,
+                extra_sources TEXT,
+                last_run      TEXT,
+                last_status   TEXT
+            )""",
+        "list_fields": ["extra_sources"],
+        "col_in":  {"extra_sources": "source"},
+        "col_out": {"source": "extra_sources"},
+    },
+
+    "proxmox_jobs": {
+        "ddl": """
+            CREATE TABLE IF NOT EXISTS proxmox_jobs (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                job         TEXT    NOT NULL DEFAULT '',
+                remote_id   TEXT,
+                type        TEXT    NOT NULL DEFAULT '',
+                enabled     INTEGER NOT NULL DEFAULT 1,
+                last_run    TEXT,
+                last_status TEXT
+            )""",
+    },
+}
+
+
+def _register_app_tables() -> None:
+    for key, cfg in _APP_TABLES.items():
+        register_table(
+            key,
+            cfg["ddl"],
+            list_fields=cfg.get("list_fields"),
+            col_in=cfg.get("col_in"),
+            col_out=cfg.get("col_out"),
+        )
+
+
+def init_db() -> None:
+    _configure_db(DB_PATH)
+    _register_app_tables()
+    create_all_registered_tables()
+
+
+# Borg-spezifischer Cache → app/modules/borg/storage.py
+from astrapi_backup.modules.borg.storage import (
+    save_archive_list_cache, save_archive_cache,
+    get_archive_cache, archive_is_cached,
+    get_file_cache, save_file_cache_for_archive,
+    get_stats_cache, save_stats_cache,
+)

astrapi_backup/api/templates.py

@@ -0,0 +1,100 @@
+# api/templates.py – zentrale Jinja2-Instanz mit ChoiceLoader (app/ > module/ > core/)
+from pathlib import Path
+from fastapi.templating import Jinja2Templates
+from jinja2 import ChoiceLoader, Environment, FileSystemLoader, PrefixLoader
+
+from astrapi_backup._paths import package_dir as _package_dir
+
+_APP_ROOT      = _package_dir()
+_APP_TEMPLATES = _APP_ROOT / "templates"
+
+import astrapi_core.ui as _astrapi_core_ui
+_CORE_TEMPLATES = Path(_astrapi_core_ui.__file__).resolve().parent / "templates"
+
+# Basis-Loader: app/templates/ > core/ui/templates/
+_base_loaders: list = [
+    FileSystemLoader(str(_APP_TEMPLATES)),
+    FileSystemLoader(str(_CORE_TEMPLATES)),
+]
+
+# PrefixLoader für jedes Modul das ein templates/-Unterverzeichnis hat
+# → render_template("borg/partials/list.html") → modules/borg/templates/partials/list.html
+_prefix_loaders: list = []
+_CORE_MODULES = Path(_astrapi_core_ui.__file__).resolve().parents[1] / "modules"
+for _search_root in (_APP_ROOT / "modules", _CORE_MODULES):
+    if not _search_root.is_dir():
+        continue
+    for _mod_dir in sorted(_search_root.iterdir()):
+        if not _mod_dir.is_dir() or _mod_dir.name.startswith("_"):
+            continue
+        _tpl_dir = _mod_dir / "templates"
+        if _tpl_dir.is_dir():
+            _prefix_loaders.append(
+                PrefixLoader({_mod_dir.name: FileSystemLoader(str(_tpl_dir))})
+            )
+
+# Environment direkt bauen und per env= übergeben – vermeidet den Jinja2 3.1.5+
+# Cache-Key-Bug bei dem globals (dict) unhashbar als LRU-Key verwendet wird.
+_env = Environment(loader=ChoiceLoader(_prefix_loaders + _base_loaders), autoescape=True, cache_size=0)
+templates = Jinja2Templates(env=_env)
+
+# Jinja2-Instanz für core-Module bereitstellen
+from astrapi_core.ui.fastapi_templates import configure as _configure_fastapi_templates
+_configure_fastapi_templates(templates)
+
+
+# ── Template-Globals: Funktionen die content.html / list_wrapper_inner.html braucht ──
+# (entsprechen den Flask-Context-Processor-Funktionen in core/ui/app.py)
+
+def _module_label(key: str) -> str:
+    from astrapi_core.ui.module_registry import _mod_registry
+    m = _mod_registry.get(key)
+    return m.label if m else key.replace("_", " ").title()
+
+
+def _module_has_settings(key: str) -> bool:
+    from astrapi_core.ui.module_registry import _mod_registry
+    m = _mod_registry.get(key)
+    return bool(m and m.settings_schema and m.settings_button)
+
+
+def _module_card_actions(key: str) -> list:
+    from astrapi_core.ui.module_registry import _mod_registry
+    m = _mod_registry.get(key)
+    return m.card_actions if m else []
+
+
+def _col_widths(module_key: str) -> str:
+    from astrapi_core.ui.settings_registry import get as settings_get
+    return settings_get(f"ui.col_widths.{module_key}", "{}")
+
+
+def _resolve_remote_host(remote_id) -> str:
+    if not remote_id:
+        return "—"
+    try:
+        from astrapi_backup.modules.remotes.engine import get_remote
+        r = get_remote(remote_id)
+        return r.get("host") or "—" if r else "—"
+    except Exception:
+        return "—"
+
+
+def _last_run_status(module: str, item_id) -> str | None:
+    try:
+        from astrapi_core.system.activity_log import list_runs_for_item
+        runs = list_runs_for_item(module, str(item_id), limit=5)
+        for run in runs:
+            if run.get("status") != "running":
+                return run.get("status")
+    except Exception:
+        pass
+    return None
+
+
+_env.globals["module_label"]        = _module_label
+_env.globals["module_has_settings"] = _module_has_settings
+_env.globals["module_card_actions"] = _module_card_actions
+_env.globals["col_widths"]          = _col_widths
+_env.globals["resolve_remote_host"] = _resolve_remote_host
+_env.globals["last_run_status"]     = _last_run_status

astrapi_backup/app.yaml

@@ -0,0 +1,2 @@
+name:         astrapi-backup
+display_name: Backup Control

astrapi_backup/modules/borg/__init__.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+from astrapi_core.ui.module_loader import load_modul
+from .jobs import run, run_single  # re-export fuer api/routers/run.py
+from .api import router
+from .ui import router as ui_router
+
+_KEY = Path(__file__).parent.name
+module = load_modul(Path(__file__).parent, _KEY, router, ui_router)
+
+try:
+    from astrapi_core.modules.scheduler.engine import register_action
+    register_action(f"{_KEY}.run", "Borg: Backup ausführen", run, source=_KEY, source_label="Borg")
+except Exception:
+    pass