From 450c782ed3397f1764f2d6be0c6137106e938490 Mon Sep 17 00:00:00 2001 From: Hitonabi Date: Fri, 25 Sep 2026 13:46:28 +0200 Subject: [PATCH] =?UTF-8?q?homelab:=20eigener=20Reiter=20=E2=80=9ESnapshot?= =?UTF-8?q?s=E2=80=9C=20mit=20Verwaltung=20(anlegen,=20l=C3=B6schen,=20zur?= =?UTF-8?q?=C3=BCcksetzen)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Die Seite /homelab/snapshots (in der Seitenleiste nach „Updates“: Snapshots sind der Rückweg der Updates) zeigt je Gerät die Snapshots mit Zeitpunkt, Alter, Herkunft (vor Update / per Knopf / von Hand) und Beschreibung, beim PBS die Sicherungen des Orchestrators mit Größe. Knöpfe „Snapshot anlegen“, „Zurücksetzen“ und „Löschen“ gibt es nur für freigegebene Geräte und nur für mc2-Snapshots bzw. eigene Sicherungen; von Hand angelegte bleiben reine Ansicht. Die Rückfragen kommen vom Homelab-Teil (wie im Ziel-Modell); Zurücksetzen sagt vorher, was verloren geht und dass das Gerät neu startet. Am Handy (320–400 px) untereinander, ab md Knöpfe rechts, ab xl fünf Spalten. Entscheide: - Ausführer: kein neuer Befehl. Der Bericht bringt zusätzlich snapshot_details (snaptime, Beschreibung, eigen) und sicherung_details (ctime, Größe); snapshots und sicherungen bleiben unverändert. Keine Belegung je Snapshot — die kennt Proxmox bei LVM-Thin nicht, die Seite sagt das so. „snapshot“ nimmt einen Anlass (update oder knopf) und wählt damit eine feste Beschreibung, damit ein Snapshot auf Knopfdruck nicht „Vor einem Update“ heißt. Bis der neue Ausführer eingespielt ist, liest der Homelab-Teil den Zeitpunkt aus dem Namen. - Aktionen sind Läufe in homelab-laeufe.json (Mechanik aus updates.py): gleiche Sperren (START_SPERRE, je Gerät einer, SAMMELLAUF_SPERRE), Protokoll-Art „snapshot“ mit eigenen Titeln, der Wächter lässt ein Gerät im Zurücksetzen in Ruhe. Zusätzlich keine Aktion, solange irgendwo ein Update läuft: Der Ausführer arbeitet einen Auftrag nach dem anderen ab — hinter einem Update liefe die Aktion in ihr Zeitlimit und käme danach unbeobachtet doch noch dran. - Zurücksetzen prüft danach wie ein Update und meldet immer ([Homelab-Snapshot], bei Rot als Alarm); anlegen und löschen melden nur ihr Scheitern, das Ergebnis steht beim Gerät. Nicht im Update-Verlauf, nicht unter „Zuletzt eingespielt“. - Per Knopf angelegte Snapshots räumt kein grünes Update weg (updates._aufraeumen fragt snapshots.knopf_namen). - speicher.py: alle Snapshots in einem Vorschlag mit Verweis auf die Seite statt einer je Snapshot. - Nebenbei: Der Update-Verlauf stürzte bei einem Ergebnis ohne Eintrag ab (etwa „offen“ nach einem Docker-Probelauf); die Protokoll-Seite stürzte im Entwicklungsmodus ab (Konstante „Symbol“ gegen das Symbol.for des React Compilers); Auftragstitel „Alter Snapshot gelöscht“ heißt jetzt „Snapshot gelöscht“ (gelöscht wird auch von Hand). Tests: pytest test_homelab_snapshots.py (Ausführer-Details, Liste, Läufe mit nachgespieltem Ausführer, Sperren, Aufräumen, Schnittstelle), test_homelab_speicher.py; Vitest SnapshotListe, lib/snapshots, Speicher. Prüftor grün. Co-Authored-By: Claude Opus 5.5 --- backend/routers/homelab.py | 41 +- backend/services/homelab/protokoll.py | 51 +- backend/services/homelab/snapshots.py | 486 ++++++++++++++++++ backend/services/homelab/speicher.py | 55 +- backend/services/homelab/updates.py | 10 +- backend/tests/test_homelab_snapshots.py | 428 +++++++++++++++ backend/tests/test_homelab_speicher.py | 26 +- deploy/homelab/ausfuehrer.py | 61 ++- docs/ARCHITEKTUR.md | 43 +- docs/BEDIENUNG.md | 32 +- frontend/src/app/router.tsx | 5 + .../components/homelab/SnapshotListe.test.tsx | 135 +++++ .../src/components/homelab/SnapshotListe.tsx | 209 ++++++++ .../src/components/homelab/Speicher.test.tsx | 7 + frontend/src/components/homelab/Speicher.tsx | 11 +- frontend/src/lib/abfragen.ts | 22 + frontend/src/lib/navigation.ts | 4 + frontend/src/lib/snapshots.test.ts | 39 ++ frontend/src/lib/snapshots.ts | 48 ++ frontend/src/lib/typen.ts | 69 ++- frontend/src/views/Homelab.tsx | 29 +- frontend/src/views/HomelabProtokoll.tsx | 14 +- frontend/src/views/HomelabSnapshots.tsx | 66 +++ frontend/src/views/Uebersicht.tsx | 4 +- 24 files changed, 1835 insertions(+), 60 deletions(-) create mode 100644 backend/services/homelab/snapshots.py create mode 100644 backend/tests/test_homelab_snapshots.py create mode 100644 frontend/src/components/homelab/SnapshotListe.test.tsx create mode 100644 frontend/src/components/homelab/SnapshotListe.tsx create mode 100644 frontend/src/lib/snapshots.test.ts create mode 100644 frontend/src/lib/snapshots.ts create mode 100644 frontend/src/views/HomelabSnapshots.tsx diff --git a/backend/routers/homelab.py b/backend/routers/homelab.py index e5548ad..c81b37d 100644 --- a/backend/routers/homelab.py +++ b/backend/routers/homelab.py @@ -6,7 +6,8 @@ POST /api/homelab/ziele/{id}/suchen Paketlisten im Gast erneuern POST /api/homelab/ziele/{id}/docker Docker über Arcane (zuerst Probelauf) POST /api/homelab/ziele/pve/neustart Proxmox-Host neu starten (eigener Knopf) - GET /api/homelab/laeufe Die letzten Update-Läufe mit ihren Schritten + GET /api/homelab/laeufe Die letzten Läufe (Updates, Snapshot-Aktionen) mit ihren Schritten + GET /api/homelab/snapshots Snapshots und Sicherungen je Gerät (Aktionen: siehe unten) GET /api/homelab/hinweise Hinweise des Wächters dieser Instanz GET /api/homelab/ausfuehrer Lebenszeichen des Ausführers GET /api/homelab/ausfuehrer/auftrag ┐ @@ -146,6 +147,44 @@ def speicher_lage() -> dict: return speicher.lage() +# --- Snapshots und Sicherungen verwalten (Seite Homelab → Snapshots, seit 25.09.2026) ------------------------------ +# GET /api/homelab/snapshots je Gerät Snapshots, Sicherungen, ob gerade etwas läuft +# POST /api/homelab/snapshots/{id}/anlegen Snapshot jetzt anlegen (freigegeben, Snapshot möglich) +# POST /api/homelab/snapshots/{id}/{name}/loeschen nur Snapshots des Orchestrators (mc2-…) +# POST /api/homelab/snapshots/{id}/{name}/zuruecksetzen ebenso; danach Prüfung wie nach einem Update +# POST /api/homelab/sicherungen/{id}/{datei}/loeschen nur Sicherungen des Orchestrators (Bericht) +# Jede Aktion ist ein Lauf wie „Jetzt updaten“; was nicht geht, beantworten sie mit 409 wie die Update-Knöpfe. + +@router.get("/snapshots") +def snapshots_liste() -> dict: + from services.homelab import snapshots + return snapshots.liste() + + +@router.post("/snapshots/{ziel_id}/anlegen") +def snapshot_anlegen(ziel_id: str) -> dict: + from services.homelab import snapshots + return _antwort(snapshots.anlegen(ziel_id)) + + +@router.post("/snapshots/{ziel_id}/{name}/loeschen") +def snapshot_loeschen(ziel_id: str, name: str) -> dict: + from services.homelab import snapshots + return _antwort(snapshots.loeschen(ziel_id, name)) + + +@router.post("/snapshots/{ziel_id}/{name}/zuruecksetzen") +def snapshot_zuruecksetzen(ziel_id: str, name: str) -> dict: + from services.homelab import snapshots + return _antwort(snapshots.zuruecksetzen(ziel_id, name)) + + +@router.post("/sicherungen/{ziel_id}/{datei}/loeschen") +def sicherung_loeschen(ziel_id: str, datei: str) -> dict: + from services.homelab import snapshots + return _antwort(snapshots.sicherung_loeschen(ziel_id, datei)) + + @router.get("/einstellungen") def einstellungen_stand() -> dict: from services.homelab import einstellungen as homelab_einstellungen diff --git a/backend/services/homelab/protokoll.py b/backend/services/homelab/protokoll.py index 3db37fb..129e9cf 100644 --- a/backend/services/homelab/protokoll.py +++ b/backend/services/homelab/protokoll.py @@ -5,6 +5,8 @@ Quellen, alle nur gelesen: Berichte nur auf Wunsch (berichte=1): die Aufträge „bericht“ der Update-Läufe und die Berichte, die der Ausführer von sich aus schickt (alle zehn Minuten; kanal.py vermerkt ihren Eingang). lauf „Jetzt updaten“-Läufe mit ihren Schritten (updates.py) + snapshot Aktionen der Seite Snapshots (snapshots.py, seit 25.09.2026): anlegen, löschen, zurücksetzen, Sicherung + löschen — Läufe wie die Updates, mit eigenen Titeln sammellauf „Alle aktualisieren“ (sammellauf.py) hinweis Hinweise des Wächters: erschienen, erledigt, Selbstreparatur (der Verlauf in mc2-waechter.json; ein Hinweis, der dort schon herausgefallen ist, erscheint mit seinem Beginn) @@ -28,7 +30,7 @@ from kern.einstellungen import einstellungen from kern.zeit import LOCAL_TZ from services.einstellungen import melde_log -from services.homelab import apps, arcane, kanal, pflege, sammellauf, updates +from services.homelab import apps, arcane, kanal, pflege, sammellauf, snapshots, updates GRENZE_MAX = 1000 DETAILS_MAX = 4000 @@ -52,12 +54,13 @@ _AKTION = { "Paketlisten erneuern"), "zurueck": ("Auf den Snapshot zurückgesetzt", "Zurücksetzen gescheitert", "Wird auf den Snapshot zurückgesetzt", "Zurücksetzen"), - "snapshot_loeschen": ("Alter Snapshot gelöscht", "Snapshot löschen gescheitert", "Alter Snapshot wird gelöscht", + # Seit 25.09.2026 nicht mehr „Alter …“: Gelöscht wird auch auf der Seite Snapshots, nicht nur nach einem Update. + "snapshot_loeschen": ("Snapshot gelöscht", "Snapshot löschen gescheitert", "Snapshot wird gelöscht", "Snapshot löschen"), "sichern": ("Sicherung angelegt", "Sicherung gescheitert", "Sicherung läuft", "Sicherung"), "sicherung_zurueck": ("Sicherung zurückgespielt", "Zurückspielen gescheitert", "Sicherung wird zurückgespielt", "Zurückspielen"), - "sicherung_loeschen": ("Alte Sicherung gelöscht", "Sicherung löschen gescheitert", "Alte Sicherung wird gelöscht", + "sicherung_loeschen": ("Sicherung gelöscht", "Sicherung löschen gescheitert", "Sicherung wird gelöscht", "Sicherung löschen"), "host_update": ("Host-Pakete eingespielt", "Host-Pakete gescheitert", "Host-Pakete werden eingespielt", "Host-Pakete"), @@ -287,7 +290,46 @@ def _anzahl_pakete(n: object, wort: str) -> str: return f"{n} {wort}{'' if n == 1 else 'e'} eingespielt" if isinstance(n, int) and n > 0 else f"{wort}e eingespielt" +# Läufe der Seite Snapshots: (Baustein, Ergebnis) → (Titel, Stufe). Gescheitert heißt dort meist: Am Gerät hat sich +# nichts geändert (warn) — nur ein gescheitertes Zurücksetzen ist rot. +_SNAPSHOT_TITEL = { + ("snapshot-anlegen", "angelegt"): ("Snapshot angelegt", "ok"), + ("snapshot-anlegen", "fehler"): ("Snapshot anlegen gescheitert", "warn"), + ("snapshot-loeschen", "geloescht"): ("Snapshot gelöscht", "ok"), + ("snapshot-loeschen", "fehler"): ("Snapshot löschen gescheitert", "warn"), + ("snapshot-zurueck", "zurueckgesetzt"): ("Zurückgesetzt, Prüfung grün", "ok"), + ("snapshot-zurueck", "fehler"): ("Zurücksetzen gescheitert", "fehler"), + ("sicherung-loeschen", "geloescht"): ("Sicherung gelöscht", "ok"), + ("sicherung-loeschen", "fehler"): ("Sicherung löschen gescheitert", "warn"), +} + + +def _snapshot_lauf(x: dict, schw: Callable) -> dict | None: + """Eine Aktion der Seite Snapshots (snapshots.py): eigene Art „snapshot“, eigene Titel.""" + name = str(x.get("name") or x.get("ziel") or "?") + baustein, status, text = str(x.get("baustein")), x.get("status"), x.get("text") + was = snapshots.WAS.get(baustein, "Snapshot-Aktion") + if status == "laeuft": + titel, stufe = f"{snapshots.LAEUFT.get(baustein, was)} · {name}", "info" + elif status == "unterbrochen": + titel, stufe = f"{was} unterbrochen · {name}", "fehler" + text = text or ("Der Homelab-Teil wurde währenddessen neu gestartet; was am Gerät geschah, zeigt der nächste " + "Bericht.") + elif baustein == "snapshot-zurueck" and x.get("ergebnis") == "fehler" and x.get("zurueckgesetzt"): + titel, stufe = f"Zurückgesetzt, Prüfung rot · {name}", "fehler" + else: + wort, stufe = _SNAPSHOT_TITEL.get((baustein, str(x.get("ergebnis"))), (f"{was} beendet", "info")) + titel = f"{wort} · {name}" + zeilen = [str(s) for s in x.get("schritte") or []] + if status == "fertig" and x.get("gemeldet") is False: + zeilen.append("Ohne Meldung: Das Ergebnis steht auf der Seite Snapshots.") + return _eintrag(x.get("ende") or x.get("start"), "snapshot", titel, text, stufe, x.get("ziel"), + "\n".join(zeilen) or None, schw) + + def _lauf(x: dict, schw: Callable) -> dict | None: + if str(x.get("baustein")) in snapshots.LAEUFT: + return _snapshot_lauf(x, schw) name = str(x.get("name") or x.get("ziel") or "?") baustein, ergebnis, status, text = x.get("baustein"), x.get("ergebnis"), x.get("status"), x.get("text") was = _LAUF_WAS.get(str(baustein), "Update") @@ -431,6 +473,9 @@ def _betreffe(laeufe: list[dict], sammellaeufe: list[dict]) -> dict[str, str]: bekannt = {} for x in laeufe: if x.get("text") and x.get("gemeldet") is not False: + if x.get("betreff"): # die Läufe der Seite Snapshots merken sich ihren Betreff selbst + bekannt[x["text"]] = x["betreff"] + continue dringend = x.get("dringend") if dringend is None: # Läufe von vor dem 24.09.2026 abends: wie updates._ende es entschied dringend = x.get("ergebnis") in ("zurueckgerollt", "fehler") and "nicht begonnen" not in x["text"] diff --git a/backend/services/homelab/snapshots.py b/backend/services/homelab/snapshots.py new file mode 100644 index 0000000..8c38506 --- /dev/null +++ b/backend/services/homelab/snapshots.py @@ -0,0 +1,486 @@ +"""Snapshots und Sicherungen verwalten — die Seite Homelab → Snapshots (seit 25.09.2026, User-Wunsch). + +Liste (liste): je Gerät aus dem Bericht des Ausführers die Snapshots mit Zeitpunkt, Beschreibung und Herkunft, dazu die +Sicherungen des Orchestrators (vzdump-Archive, heute nur beim PBS, der keinen Snapshot kann) und ob für das Gerät +gerade ein Lauf läuft. Ein Ausführer vor dem 25.09.2026 liefert nur die Namen (snapshots, sicherungen): Dann kommt der +Zeitpunkt aus dem Namen (mc2-JJJJMMTT-HHMMSS bzw. …-JJJJ_MM_TT-HH_MM_SS, Ortszeit des Hosts), von Hand angelegte +Snapshots stehen ohne Zeit da. Wie viel ein Snapshot belegt, sagt Proxmox bei LVM-Thin nicht — hier steht deshalb keine +Zahl, die Seite sagt es so. + +Herkunft eines Snapshots: + update Rückweg vor einem Update (Name mc2-…) + knopf „Snapshot anlegen“ auf dieser Seite (Name mc2-…; der Ausführer schreibt „Auf Knopfdruck …“ in die + Beschreibung, und der Lauf hier merkt sich den Namen). Solche räumt kein grünes Update weg + (updates._aufraeumen fragt knopf_namen) — die löscht nur der User. + proxmox von Hand in Proxmox angelegt: nur zur Ansicht, nie gelöscht oder zurückgesetzt (der Ausführer lehnt das + ohnehin ab, er fasst nur mc2-… an). + +Die Aktionen laufen als Läufe wie „Jetzt updaten“ (Mechanik aus updates.py, bewusst mitbenutzt): in +homelab-laeufe.json, je Gerät höchstens einer, nie während „Alle aktualisieren“ (SAMMELLAUF_SPERRE) oder eines Updates +irgendwo (_sperre: der Ausführer arbeitet einen Auftrag nach dem anderen ab) und nur, wenn der Ausführer verbunden ist. +So stehen sie im Protokoll, der Wächter lässt ein Gerät mitten im Zurücksetzen in Ruhe, und nichts kommt einem Update +in die Quere. Neue Befehle braucht der Ausführer nicht: + snapshot-anlegen snapshot (Anlass „knopf“) → frischer Bericht. Eine Meldung nur, wenn es scheitert. + snapshot-loeschen snapshot_loeschen (nur mc2-…) → frischer Bericht. Eine Meldung nur, wenn es scheitert. + snapshot-zurueck zurueck (nur mc2-…; der Ausführer stoppt, setzt zurück, startet) → 20 s warten → frischer Bericht + → Prüfung wie nach einem Update (läuft, Weboberfläche antwortet). Immer mit Meldung, dringend, wenn + es scheitert oder die Prüfung rot ist. + sicherung-loeschen sicherung_loeschen (nur Sicherungen des Orchestrators) → frischer Bericht. Meldung nur bei Fehler. +Im Update-Verlauf stehen sie nicht: Das sind keine Updates. +""" + +import logging +import re +import threading +import time +from collections.abc import Callable +from datetime import datetime + +from kern.zeit import LOCAL_TZ + +from services import announce +from services.homelab import apps, inventar, kanal, sammellauf, updates + +log = logging.getLogger(__name__) + +# Wie SNAPSHOT_NAME im Ausführer: Nur solche Snapshots fasst er an. Der Zeitpunkt im Namen ist die Ortszeit des +# Proxmox-Hosts (Europe/Berlin, wie LOCAL_TZ). +SNAPSHOT_NAME = re.compile(r"^mc2-(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})$") +ARCHIV_ZEIT = re.compile(r"-(\d{4})_(\d{2})_(\d{2})-(\d{2})_(\d{2})_(\d{2})\.") +KNOPF_BESCHREIBUNG = "Auf Knopfdruck" # so beginnt die Beschreibung, die der Ausführer beim Anlass „knopf“ setzt +# Die Läufe dieser Seite: was gerade geschieht (für „Läuft: …“) und wie die Aktion heißt. +LAEUFT = {"snapshot-anlegen": "Snapshot wird angelegt", "snapshot-loeschen": "Snapshot wird gelöscht", + "snapshot-zurueck": "Wird zurückgesetzt", "sicherung-loeschen": "Sicherung wird gelöscht"} +WAS = {"snapshot-anlegen": "Snapshot anlegen", "snapshot-loeschen": "Snapshot löschen", + "snapshot-zurueck": "Zurücksetzen", "sicherung-loeschen": "Sicherung löschen"} +GUT = {"angelegt", "geloescht", "zurueckgesetzt"} +ZULETZT_S = 6 * 3600 # so lange steht das Ergebnis der letzten Aktion beim Gerät +BETREFF = "[Homelab-Snapshot]" +BETREFF_ALARM = "[Alarm] Homelab-Snapshot" + + +# --- Kleine Helfer ------------------------------------------------------------------------------------------------- + +def _zid(g: dict) -> str: + return f"{'ct' if g.get('art') == 'lxc' else 'vm'}-{g['vmid']}" + + +def _wo(g: dict) -> str: + return f"{'Container' if g.get('art') == 'lxc' else 'VM'} {g['vmid']}" + + +def _name(g: dict) -> str: + """Der Name wie in der Update-Liste (Gitea, Arcane (Docker) …).""" + app = apps.app_fuer((g.get("app") or {}).get("kennung"), g.get("name")) + return app.name if app else str(g.get("name") or _zid(g)) + + +def _ortszeit(m: re.Match | None) -> float | None: + if not m: + return None + try: + return datetime(*(int(x) for x in m.groups()), tzinfo=LOCAL_TZ).timestamp() + except ValueError: + return None + + +def _wann(ts: float | None) -> str: + """„vom 25.09.2026 11:26“ — leer, wo der Zeitpunkt fehlt.""" + return f"vom {datetime.fromtimestamp(ts, LOCAL_TZ):%d.%m.%Y %H:%M}" if ts else "" + + +def _groesse(n: int | None) -> str | None: + if not n: + return None + return f"{n / 1e6:.0f} MB" if n < 1e9 else f"{n / 1e9:.1f} GB".replace(".", ",") + + +def _aktion(pfad: str, frage: str, label: str) -> dict: + """Ein Knopf wie im Ziel-Modell (kern/ziele.py: Aktion): Methode, Pfad, Rückfrage, Beschriftung.""" + return {"methode": "POST", "pfad": pfad, "frage": frage, "label": label} + + +def _grund(exc: Exception) -> str: + return str(exc).rstrip(".") + + +# --- Snapshots und Sicherungen eines Geräts --------------------------------------------------------------------------- + +def _knopf(laeufe: list[dict]) -> set[tuple[str, str]]: + """(Gerät, Snapshot) aus den Läufen „Snapshot anlegen“ — so erkennt die Seite ihre Snapshots auch mit einem + Ausführer, der die Beschreibung „Auf Knopfdruck …“ noch nicht schreibt.""" + return {(str(x.get("ziel")), str(x["snapshot"])) for x in laeufe + if x.get("baustein") == "snapshot-anlegen" and x.get("snapshot")} + + +def knopf_namen(ziel_id: str, gast: dict) -> set[str]: + """Die Snapshots eines Gasts, die jemand auf der Seite Snapshots angelegt hat. Kein grünes Update räumt sie weg + (updates._aufraeumen) — die löscht nur der User.""" + namen = {name for ziel, name in _knopf(updates.laeufe(100)) if ziel == ziel_id} + for d in gast.get("snapshot_details") or []: + if isinstance(d, dict) and str(d.get("beschreibung") or "").startswith(KNOPF_BESCHREIBUNG): + namen.add(str(d.get("name"))) + return namen + + +def _snapshots(g: dict, zid: str, knopf: set[tuple[str, str]]) -> list[dict]: + """Die Snapshots eines Gasts, ältester zuerst: Name, Zeitpunkt, Beschreibung, Herkunft, ob vom Orchestrator.""" + details = g.get("snapshot_details") + roh = ([d for d in details if isinstance(d, dict) and d.get("name")] if isinstance(details, list) + else [{"name": n} for n in g.get("snapshots") or [] if n]) + liste = [] + for d in roh: + name = str(d["name"]) + m = SNAPSHOT_NAME.match(name) + zeit = d.get("zeit") if isinstance(d.get("zeit"), (int, float)) else _ortszeit(m) + beschreibung = str(d.get("beschreibung") or "").strip() or None + if not m: + herkunft = "proxmox" + elif (zid, name) in knopf or (beschreibung or "").startswith(KNOPF_BESCHREIBUNG): + herkunft = "knopf" + else: + herkunft = "update" + liste.append({"name": name, "zeit": zeit, "beschreibung": beschreibung, "herkunft": herkunft, + "eigen": bool(m)}) + return sorted(liste, key=lambda s: (s["zeit"] or 0, s["name"])) + + +def _sicherungen(g: dict) -> list[dict]: + """Die Sicherungen des Orchestrators für diesen Gast (der Ausführer nennt nur eigene), älteste zuerst.""" + details = g.get("sicherung_details") + roh = ([d for d in details if isinstance(d, dict) and d.get("volid")] if isinstance(details, list) + else [{"volid": v} for v in g.get("sicherungen") or [] if v]) + liste = [] + for d in roh: + volid = str(d["volid"]) + datei = volid.rsplit("/", 1)[-1] + zeit = d.get("zeit") if isinstance(d.get("zeit"), (int, float)) else _ortszeit(ARCHIV_ZEIT.search(datei)) + groesse = d.get("groesse") if isinstance(d.get("groesse"), int) else None + liste.append({"datei": datei, "speicher": volid.split(":", 1)[0], "zeit": zeit, "groesse": groesse}) + return sorted(liste, key=lambda e: (e["zeit"] or 0, e["datei"])) + + +def _anlegen_grund(g: dict) -> str | None: + """Warum es für diesen Gast keinen Knopf „Snapshot anlegen“ gibt — oder None.""" + if not g.get("erlaubt"): + return ("Nicht freigegeben: Das Etikett „watcher“ fehlt (oder „watcher-aus“ ist gesetzt). Der Orchestrator fasst " + "dieses Gerät nicht an; Snapshots gehen hier nur von Hand in Proxmox.") + if "snapshot_moeglich" not in g: + return "Ob ein Snapshot geht, ließ sich nicht lesen" + (f": {g['fehler']}" if g.get("fehler") else ".") + if not g["snapshot_moeglich"]: + satz = f"Kein Snapshot möglich: {str(g.get('snapshot_grund') or 'Der Speicher kann keine').rstrip('.')}." + if g.get("sicherung_moeglich"): + satz += " Vor einem Update legt der Orchestrator stattdessen eine Sicherung an." + return satz + return None + + +# --- Rückfragen (die Oberfläche zeigt sie wörtlich) --------------------------------------------------------------- + +def _frage_anlegen(g: dict, name: str) -> str: + vm = g.get("art") != "lxc" + saetze = [f"Jetzt einen Snapshot von {name} ({_wo(g)}) anlegen?"] + if g.get("status") == "running": + saetze.append(f"{'Die VM' if vm else 'Der Container'} läuft dabei weiter.") + saetze.append("Diesen Snapshot räumt kein Update weg — du löschst ihn hier, wenn du ihn nicht mehr brauchst.") + saetze.append("Die VM schreibt laufend; ihr Snapshot wächst im Speicherpool schnell mit, also nicht lange stehen " + "lassen." if vm else "Im Speicherpool belegt er so viel, wie sich seitdem im Container ändert.") + return " ".join(saetze) + + +def _frage_loeschen(name: str, s: dict) -> str: + wie = "Rückweg eines Updates" if s["herkunft"] == "update" else "auf Knopfdruck angelegt" + return (f"Den Snapshot {s['name']} von {name} ({', '.join(t for t in (_wann(s['zeit']), wie) if t)}) endgültig " + "löschen? Am Gerät selbst ändert sich nichts; nur der Weg zurück auf diesen Stand ist danach weg.") + + +def _frage_zurueck(g: dict, name: str, s: dict) -> str: + vm = g.get("art") != "lxc" + wann = _wann(s["zeit"]) + stand = f"den Snapshot {wann} ({s['name']})" if wann else f"den Snapshot {s['name']}" + saetze = [f"{name} ({_wo(g)}) auf {stand} zurücksetzen?", + (f"Alles, was sich seitdem {'in der VM' if vm else 'im Container'} geändert hat — Daten, Einstellungen, " + "Updates —, ist danach verloren. Rückgängig machen lässt sich das nicht."), + (f"{'Die VM' if vm else 'Der Container'} wird dafür gestoppt und wieder gestartet; " + f"{name} ist ein paar Minuten nicht erreichbar.")] + if g.get("status") != "running": + saetze.append(f"Gerade {'ist die VM' if vm else 'ist der Container'} gestoppt — danach läuft " + f"{'sie' if vm else 'er'}.") + saetze.append(f"Danach prüft der Orchestrator, ob {name} wieder antwortet, und meldet das Ergebnis. Willst du den " + "jetzigen Stand behalten, lege vorher einen Snapshot an.") + return " ".join(saetze) + + +def _frage_sicherung(name: str, e: dict) -> str: + teile = [t for t in (_wann(e["zeit"]), _groesse(e["groesse"])) if t] + [f"auf „{e['speicher']}“"] + return (f"Die Sicherung {e['datei']} von {name} ({', '.join(teile)}) endgültig löschen? Der Orchestrator hat sie " + "vor einem Update als Rückweg angelegt. Am Gerät selbst ändert sich nichts, und die nächtlichen Sicherungen " + "(Proxmox → Backup) bleiben, wie sie sind.") + + +# --- Liste für die Oberfläche ------------------------------------------------------------------------------------------ + +def _laeuft_text(x: dict) -> str: + """Was für ein Gerät gerade läuft, in Worten — auch ein Update, das die Knöpfe hier sperrt.""" + baustein = str(x.get("baustein")) + if baustein == "snapshot-zurueck" and "zurueck: ok" in (x.get("schritte") or []): + return "Zurückgesetzt, wird geprüft" + return LAEUFT.get(baustein, "Update läuft") + + +def _zuletzt(x: dict | None, jetzt: float) -> dict | None: + """Das Ergebnis der letzten Aktion dieser Seite für ein Gerät, solange es frisch ist (ZULETZT_S).""" + ende = (x or {}).get("ende") or (x or {}).get("start") + if not isinstance(ende, (int, float)) or jetzt - ende > ZULETZT_S: + return None + if x.get("status") == "unterbrochen": + return {"ok": False, "ende": ende, + "text": f"{WAS.get(str(x.get('baustein')), 'Die Aktion')} unterbrochen: Der Homelab-Teil wurde " + "währenddessen neu gestartet. Was am Gerät geschah, zeigt die Liste."} + return {"ok": x.get("ergebnis") in GUT, "ende": ende, "text": str(x.get("text") or "")} + + +def _geraet(g: dict, laufend: dict[str, dict], fertig: dict[str, dict], knopf: set, jetzt: float) -> dict: + zid, name = _zid(g), _name(g) + grund = _anlegen_grund(g) + snapshots = _snapshots(g, zid, knopf) + for s in snapshots: + darf = s["eigen"] and bool(g.get("erlaubt")) + pfad = f"/api/homelab/snapshots/{zid}/{s['name']}" + s["loeschen"] = _aktion(f"{pfad}/loeschen", _frage_loeschen(name, s), "Snapshot löschen") if darf else None + s["zuruecksetzen"] = (_aktion(f"{pfad}/zuruecksetzen", _frage_zurueck(g, name, s), "Zurücksetzen") + if darf else None) + sicherungen = _sicherungen(g) + for e in sicherungen: + e["loeschen"] = (_aktion(f"/api/homelab/sicherungen/{zid}/{e['datei']}/loeschen", _frage_sicherung(name, e), + "Sicherung löschen") if g.get("erlaubt") else None) + lauf = laufend.get(zid) + return {"id": zid, "vmid": g["vmid"], "art": "container" if g.get("art") == "lxc" else "vm", "name": name, + "wo": _wo(g), "status": g.get("status"), "erlaubt": bool(g.get("erlaubt")), + "anlegen": None if grund else _aktion(f"/api/homelab/snapshots/{zid}/anlegen", _frage_anlegen(g, name), + "Snapshot anlegen"), + "grund": grund, "laeuft": _laeuft_text(lauf) if lauf else None, "zuletzt": _zuletzt(fertig.get(zid), jetzt), + "snapshots": snapshots, "sicherungen": sicherungen} + + +def liste(jetzt: float | None = None) -> dict: + """GET /api/homelab/snapshots: je Gerät (ohne den Container des Orchestrators selbst) Snapshots und Sicherungen.""" + jetzt = time.time() if jetzt is None else jetzt + eingang = kanal.bericht() + bericht = (eingang or {}).get("bericht") or {} + zuletzt = kanal.zuletzt() + gaeste = [g for g in bericht.get("gaeste") or [] if isinstance(g, dict) and isinstance(g.get("vmid"), int) + and inventar.EIGENES_ETIKETT not in (g.get("etiketten") or [])] + laeufe = updates.laeufe(100) # neueste zuerst + laufend: dict[str, dict] = {} + fertig: dict[str, dict] = {} + for x in laeufe: + if x.get("status") == "laeuft": + laufend.setdefault(str(x.get("ziel")), x) + elif x.get("baustein") in LAEUFT: + fertig.setdefault(str(x.get("ziel")), x) + knopf = _knopf(laeufe) + geraete = [_geraet(g, laufend, fertig, knopf, jetzt) for g in sorted(gaeste, key=lambda g: g["vmid"])] + alle = [s for g in geraete for s in g["snapshots"]] + sicherungen = [e for g in geraete for e in g["sicherungen"]] + empfangen = (eingang or {}).get("empfangen") + return { + "jetzt": jetzt, + "bericht": {"empfangen": empfangen, "veraltet": jetzt - empfangen > inventar.BERICHT_ALT_S} if eingang else None, + "ausfuehrer": {"verbunden": bool(zuletzt and jetzt - zuletzt < inventar.BERICHT_ALT_S), "zuletzt": zuletzt, + "nur_lesen": bool((bericht.get("host") or {}).get("nur_lesen"))}, + # Warum gerade keine Aktion geht („Alle aktualisieren“, ein Update, der Ausführer) — wie die Knöpfe es sagten. + "sperre": _sperre(), + # Ausführer vor dem 25.09.2026: nur Namen, Zeitpunkte aus dem Namen, keine Beschreibung. + "details": any("snapshot_details" in g for g in gaeste), + "geraete": geraete, + "summe": {"snapshots": len(alle), "eigene": sum(1 for s in alle if s["eigen"]), "sicherungen": len(sicherungen), + "sicherungen_groesse": sum(e["groesse"] or 0 for e in sicherungen) or None}, + } + + +# --- Aktionen ------------------------------------------------------------------------------------------------------ + +def _sperre() -> str | None: + """Warum gerade gar keine Aktion dieser Seite geht — oder None. Derselbe Satz steht auf der Seite über der Liste. + + Läuft irgendwo ein Update, warten alle: Der Ausführer arbeitet einen Auftrag nach dem anderen ab. Hinter einem + Update (bis zu einer Stunde) liefe eine Aktion in ihr Zeitlimit — und käme danach doch noch dran, ohne dass ein + Lauf hinsieht; beim Zurücksetzen wäre das gefährlich. Vor Aktionen dieser Seite stehen so nur kurze Aufträge. + Umgekehrt darf ein Update neben ihnen starten: Es wartet höchstens ein paar Sekunden.""" + if sammellauf.laeuft(): + return f"{updates.SAMMELLAUF_SPERRE} Bis es fertig ist, ruhen die Knöpfe hier." + im_update = [str(x.get("name") or x.get("ziel")) for x in updates.laeufe(100) + if x.get("status") == "laeuft" and x.get("baustein") not in LAEUFT] + if im_update: + return (f"Gerade läuft ein Update ({', '.join(dict.fromkeys(im_update))}). Anlegen, löschen und zurücksetzen " + "geht, sobald es fertig ist — der Ausführer arbeitet einen Auftrag nach dem anderen ab.") + zuletzt = kanal.zuletzt() + if not (zuletzt and time.time() - zuletzt < inventar.BERICHT_ALT_S): + return ("Der Ausführer auf dem Proxmox-Host meldet sich nicht. Die Liste zeigt den letzten bekannten Stand; " + "anlegen, löschen und zurücksetzen geht erst, wenn er wieder da ist.") + if (((kanal.bericht() or {}).get("bericht") or {}).get("host") or {}).get("nur_lesen"): + return "Der Ausführer läuft im Nur-Lesen-Modus: Er zeigt alles, ändert aber nichts." + return None + + +def _vorab(ziel_id: str) -> tuple[dict | None, str | None]: + """Was vor jeder Aktion gelten muss (unter updates.START_SPERRE geprüft): (Gast, None) oder (None, warum nicht).""" + if grund := _sperre(): + return None, grund + if updates.laeuft(ziel_id): + return None, ("Für dieses Gerät läuft gerade schon etwas (ein Update oder eine Snapshot-Aktion). Das geht " + "erst, wenn es fertig ist.") + gast = inventar.gast(ziel_id) + if not gast or inventar.EIGENES_ETIKETT in (gast.get("etiketten") or []): + return None, "Dieses Gerät steht nicht im Bericht des Ausführers." + if not gast.get("erlaubt"): + return None, "Dieses Gerät ist nicht freigegeben (Etikett „watcher“ fehlt); der Ausführer fasst es nicht an." + return gast, None + + +def _starten(ziel_id: str, baustein: str, vorbereiten: Callable[[dict], tuple[str | None, dict]], + schritte: Callable[[dict, dict], None]) -> dict: + """Prüfen und den Lauf anlegen am Stück (wie updates.starten), dann im eigenen Faden ablaufen lassen. + Rückgabe {"ok": True, "lauf": id} oder {"ok": False, "detail": …}.""" + with updates.START_SPERRE: + gast, grund = _vorab(ziel_id) + mehr: dict = {} + if gast is not None: + grund, mehr = vorbereiten(gast) + if grund or gast is None: + return {"ok": False, "detail": grund or "Das geht gerade nicht."} + lauf = updates._neuer_lauf(ziel_id, baustein, _name(gast), **mehr) + threading.Thread(target=_ablauf, args=(schritte, lauf, gast), name=f"homelab-{ziel_id}", daemon=True).start() + return {"ok": True, "lauf": lauf["id"]} + + +def _eigener_snapshot(gast: dict, name: str) -> tuple[str | None, dict]: + if not SNAPSHOT_NAME.match(name): + return ("Nur Snapshots des Orchestrators (mc2-…) lassen sich hier löschen oder zurücksetzen; von Hand " + "angelegte verwaltest du in Proxmox."), {} + s = next((s for s in _snapshots(gast, "", set()) if s["name"] == name), None) + if s is None: + return f"Den Snapshot {name} gibt es laut dem letzten Bericht nicht (mehr).", {} + return None, {"snapshot": name, "snapshot_zeit": s["zeit"]} + + +def anlegen(ziel_id: str) -> dict: + """Knopf „Snapshot anlegen“: nur freigegebene Gäste, auf deren Speicher ein Snapshot geht.""" + return _starten(ziel_id, "snapshot-anlegen", lambda g: (_anlegen_grund(g), {}), _anlegen) + + +def loeschen(ziel_id: str, name: str) -> dict: + """Knopf „Löschen“ an einem Snapshot des Orchestrators.""" + return _starten(ziel_id, "snapshot-loeschen", lambda g: _eigener_snapshot(g, name), _loeschen) + + +def zuruecksetzen(ziel_id: str, name: str) -> dict: + """Knopf „Zurücksetzen“ an einem Snapshot des Orchestrators.""" + return _starten(ziel_id, "snapshot-zurueck", lambda g: _eigener_snapshot(g, name), _zurueck) + + +def sicherung_loeschen(ziel_id: str, datei: str) -> dict: + """Knopf „Löschen“ an einer Sicherung des Orchestrators (nur, was der Bericht als eigene nennt).""" + def vorbereiten(gast: dict) -> tuple[str | None, dict]: + volid = next((str(v) for v in gast.get("sicherungen") or [] if str(v).rsplit("/", 1)[-1] == datei), None) + if volid is None: + return f"Die Sicherung {datei} gibt es laut dem letzten Bericht nicht (mehr).", {} + return None, {"sicherung": volid} + return _starten(ziel_id, "sicherung-loeschen", vorbereiten, _sicherung_loeschen) + + +# --- Abläufe (im eigenen Faden) -------------------------------------------------------------------------------------- + +def _ende(lauf: dict, ergebnis: str, text: str, melden: bool = False, dringend: bool = False) -> None: + betreff = (BETREFF_ALARM if dringend else BETREFF) if melden else None + lauf.update(status="fertig", ergebnis=ergebnis, text=text, ende=time.time(), dringend=dringend, gemeldet=melden, + betreff=betreff) + updates._merken(lauf) + if betreff: + try: + announce.notify_telegram(betreff, text) + except Exception: + log.warning("homelab: Meldung zu %s ging nicht raus", lauf.get("baustein"), exc_info=True) + + +def _ablauf(schritte: Callable[[dict, dict], None], lauf: dict, gast: dict) -> None: + try: + schritte(lauf, gast) + except Exception as exc: + # Sonst hieße der Lauf bis zum nächsten Neustart „läuft“, und das Gerät wäre für alles gesperrt. + log.exception("homelab: %s für %s ist abgestürzt", lauf.get("baustein"), lauf.get("ziel")) + _ende(lauf, "fehler", f"{lauf['name']}: {WAS.get(lauf['baustein'], 'Die Aktion')} ist mit einem internen " + f"Fehler stehen geblieben ({exc.__class__.__name__}).", melden=True) + + +def _anlegen(lauf: dict, gast: dict) -> None: + vmid, name = gast["vmid"], lauf["name"] + try: + a = updates._auftrag(lauf, "snapshot", {"vmid": vmid, "anlass": "knopf"}, updates.ZEITLIMIT_KURZ_S) + except RuntimeError as exc: + _ende(lauf, "fehler", f"{name}: Snapshot nicht angelegt — {_grund(exc)}.", melden=True) + return + m = re.search(r"snapshot=(mc2-\d{8}-\d{6})", a.get("text") or "") + lauf["snapshot"] = m.group(1) if m else None + nachher = updates._frischer_gast(lauf, vmid) + if lauf["snapshot"] and nachher is not None and lauf["snapshot"] not in (nachher.get("snapshots") or []): + _ende(lauf, "fehler", f"{name}: Der Ausführer meldete den Snapshot {lauf['snapshot']}, im neuen Bericht fehlt " + "er aber.", melden=True) + return + _ende(lauf, "angelegt", f"{name}: Snapshot {lauf['snapshot']} angelegt." if lauf["snapshot"] + else f"{name}: Snapshot angelegt.") + + +def _loeschen(lauf: dict, gast: dict) -> None: + vmid, name, snapshot = gast["vmid"], lauf["name"], lauf["snapshot"] + try: + updates._auftrag(lauf, "snapshot_loeschen", {"vmid": vmid, "snapshot": snapshot}, updates.ZEITLIMIT_KURZ_S) + except RuntimeError as exc: + _ende(lauf, "fehler", f"{name}: Snapshot {snapshot} ließ sich nicht löschen — {_grund(exc)}.", melden=True) + return + updates._frischer_gast(lauf, vmid) + _ende(lauf, "geloescht", f"{name}: Snapshot {snapshot} gelöscht.") + + +def _lage(name: str, gast: dict | None) -> str: + """Wie es dem Gerät nach einem gescheiterten Zurücksetzen geht, laut frischem Bericht.""" + if gast is None: + return f"Ob {name} läuft, ließ sich nicht prüfen — bitte in Proxmox nachsehen." + if gast.get("status") == "running": + return f"{name} läuft." + return f"{name} läuft nicht ({gast.get('status')}) — bitte in Proxmox nachsehen." + + +def _zurueck(lauf: dict, gast: dict) -> None: + vmid, name, snapshot = gast["vmid"], lauf["name"], lauf["snapshot"] + wann = _wann(lauf.get("snapshot_zeit")) + stand = f"den Snapshot {wann} ({snapshot})" if wann else f"den Snapshot {snapshot}" + try: + updates._auftrag(lauf, "zurueck", {"vmid": vmid, "snapshot": snapshot}, updates.ZEITLIMIT_KURZ_S) + except RuntimeError as exc: + nachher = updates._frischer_gast(lauf, vmid) + _ende(lauf, "fehler", f"{name}: Zurücksetzen auf {stand} gescheitert — {_grund(exc)}. {_lage(name, nachher)}", + melden=True, dringend=True) + return + lauf["zurueckgesetzt"] = True + time.sleep(updates.WARTEN_NACH_UPDATE_S) + nachher = updates._frischer_gast(lauf, vmid) + fehler = updates.pruefen(gast, nachher, "zurueck") + if fehler: + _ende(lauf, "fehler", f"{name}: auf {stand} zurückgesetzt, aber die Prüfung ist rot — {' '.join(fehler)}", + melden=True, dringend=True) + return + _ende(lauf, "zurueckgesetzt", f"{name}: auf {stand} zurückgesetzt, Prüfung grün.", melden=True) + + +def _sicherung_loeschen(lauf: dict, gast: dict) -> None: + vmid, name, volid = gast["vmid"], lauf["name"], lauf["sicherung"] + datei = volid.rsplit("/", 1)[-1] + try: + updates._auftrag(lauf, "sicherung_loeschen", {"vmid": vmid, "sicherung": volid}, updates.ZEITLIMIT_KURZ_S) + except RuntimeError as exc: + _ende(lauf, "fehler", f"{name}: Sicherung {datei} ließ sich nicht löschen — {_grund(exc)}.", melden=True) + return + updates._frischer_gast(lauf, vmid) + _ende(lauf, "geloescht", f"{name}: Sicherung {datei} gelöscht.") diff --git a/backend/services/homelab/speicher.py b/backend/services/homelab/speicher.py index 8f975cd..57580d9 100644 --- a/backend/services/homelab/speicher.py +++ b/backend/services/homelab/speicher.py @@ -4,7 +4,7 @@ Alles aus dem Bericht des Ausführers (alle 10 Minuten), dazu eine eigene Prüfu • Speicherpool (Thin-LVM, heute local-lvm): Läuft er voll, stehen alle Gäste darauf still. Gelb ab 80 %, rot ab 90 % — also bei 10 % frei (User-Vorgabe) —, für Daten wie Metadaten. Dazu Empfehlungen, was Platz bringt, der größte Gewinn zuerst: Platz, den ein Gast längst freigegeben hat (TRIM), ungenutzte und verwaiste Platten, - Snapshots. + Snapshots (seit 25.09.2026 in einem Vorschlag, verwaltet auf der Seite Homelab → Snapshots). • NAS: jedes Netzlaufwerk des Proxmox-Hosts (heute das QNAP per NFS, Ziel der nächtlichen Sicherungen): antwortet, ist eingebunden, hängt nicht, hat Platz (80/90 % wie oben). • Sicherungen: Für jeden Gast, den ein Sicherungsauftrag erfasst, liegt auf dessen Ziel eine frische Sicherung @@ -23,6 +23,7 @@ from datetime import datetime from kern.zeit import LOCAL_TZ from services.homelab import apps, kanal +from services.homelab.inventar import EIGENES_ETIKETT GELB, ROT = 0.80, 0.90 EMPFEHLUNG_AB = 1_000_000_000 # kleinere Gewinne sind keine eigene Empfehlung wert @@ -135,20 +136,50 @@ def empfehlungen(bericht: dict) -> list[dict]: if kernel := _kernel_vorschlag(bericht.get("host") or {}): liste.append(kernel) liste.sort(key=lambda e: -(e["platz"] or 0)) - for g in gaeste: - for s in g.get("snapshots") or []: - m = re.fullmatch(r"mc2-(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})\d{2}", s) - wann = f"vom {m.group(3)}.{m.group(2)}. {m.group(4)}:{m.group(5)}" if m else "von Hand angelegt" - liste.append({ - "art": "snapshot", "platz": None, "titel": f"{_name(g)}: Snapshot {s}", "kurz": f"Snapshot bei {_name(g)}", - "ort": "pool", - "text": ((f"Rückweg des Updates {wann}. Läuft {_name(g)} seitdem gut, kann er weg" if m else - f"Snapshot {wann}. Wird er nicht mehr gebraucht, kann er weg") - + f": in Proxmox {_wo(g)} → Snapshots → {s} → Entfernen. Wie viel er belegt, sagt Proxmox " - "nicht — bei Containern meist wenig, er wächst mit jeder Änderung seitdem.")}) + if snapshots := _snapshot_vorschlag(gaeste): + liste.append(snapshots) return liste +def _geraete_text(namen: list[str]) -> str: + """„Gitea (2), NetBird und AdGuard Home“ — je Gerät einmal, mit der Zahl, wo es mehrere sind.""" + teile = [f"{n} ({namen.count(n)})" if namen.count(n) > 1 else n for n in dict.fromkeys(namen)] + return teile[0] if len(teile) == 1 else ", ".join(teile[:-1]) + " und " + teile[-1] + + +def _snapshot_vorschlag(gaeste: list[dict]) -> dict | None: + """Alle Snapshots in EINEM Vorschlag (seit 25.09.2026; vorher einer je Snapshot): Verwalten lassen sie sich auf der + Seite Homelab → Snapshots, mit Zeitpunkt und Knöpfen. Der Container des Orchestrators selbst fehlt dort wie hier. + Wie viel sie belegen, sagt Proxmox nicht — deshalb ohne Größe und zuletzt.""" + eigene: list[str] = [] + von_hand: list[str] = [] + for g in gaeste: + if EIGENES_ETIKETT in (g.get("etiketten") or []): + continue + for s in g.get("snapshots") or []: + (eigene if re.fullmatch(r"mc2-\d{8}-\d{6}", str(s)) else von_hand).append(_name(g)) + anzahl = len(eigene) + len(von_hand) + if not anzahl: + return None + if eigene: + titel = (f"{len(eigene)} Snapshot{'s' if len(eigene) != 1 else ''} des Orchestrators — verwalten unter " + "Homelab → Snapshots") + text = (f"Bei {_geraete_text(eigene)}. Läuft ein Gerät seit seinem Snapshot gut, kann der weg — auf der Seite " + "Snapshots per Knopf, dort auch mit Zeitpunkt und dem Weg zurück.") + else: + titel = (f"{len(von_hand)} von Hand angelegte{'r' if len(von_hand) == 1 else ''} " + f"Snapshot{'s' if len(von_hand) != 1 else ''} — ansehen unter Homelab → Snapshots") + text = f"Bei {_geraete_text(von_hand)}." + if eigene and von_hand: + text += f" Dazu {len(von_hand)} von Hand in Proxmox angelegt ({_geraete_text(von_hand)})." + if von_hand: + text += " Von Hand angelegte löscht der Orchestrator nicht; das geht in Proxmox." + text += (" Wie viel ein Snapshot belegt, sagt Proxmox nicht — bei Containern meist wenig, er wächst mit jeder " + "Änderung seitdem.") + return {"art": "snapshot", "platz": None, "ort": "pool", "titel": titel, "text": text, + "kurz": f"{anzahl} Snapshot{'s' if anzahl != 1 else ''} (Homelab → Snapshots)"} + + def _kernel_vorschlag(host: dict) -> dict | None: """Alte Kernel auf der Systemplatte des Hosts — mit Knopf. Die Liste stammt vom Ausführer (was apt für entbehrlich hält, nie der laufende oder der nächste); beim Klick bestimmt er sie noch einmal selbst.""" diff --git a/backend/services/homelab/updates.py b/backend/services/homelab/updates.py index 8f26b06..46ae658 100644 --- a/backend/services/homelab/updates.py +++ b/backend/services/homelab/updates.py @@ -12,7 +12,8 @@ Ablauf für einen Gast: 3. 20 s warten, frischen Bericht holen 4. Prüfen: läuft der Gast, antwortet die Weboberfläche, ist die App-Version jetzt neuer? 5. Rot → zurück auf den Snapshot bzw. die Sicherung zurückspielen → dringende Meldung. - Grün → ältere Snapshots bzw. Sicherungen des Orchestrators für diesen Gast weg → Meldung „eingespielt“. + Grün → ältere Snapshots bzw. Sicherungen des Orchestrators für diesen Gast weg (nicht die, die jemand auf der + Seite Snapshots per Knopf angelegt hat, snapshots.py) → Meldung „eingespielt“. Docker-Images (Arcane, VM 106) gehen über Arcanes eigenen Updater: bis zum Schalter „echt“ nur als Probelauf, danach genauso mit Snapshot vorher und Rückweg bei Rot — sofern die VM freigegeben ist (Etikett watcher, seit 25.09.), sonst ohne; Rückfrage und Update-Liste sagen es. Nach grüner Prüfung geht dieser Snapshot gleich wieder weg. @@ -228,11 +229,14 @@ def _gast_lauf(lauf: dict, gast: dict) -> None: def _aufraeumen(lauf: dict, vmid: int, rueckweg: tuple[str, str] | None) -> None: """Ältere Snapshots des Orchestrators für diesen Gast löschen, nach einer Sicherung auch ältere Sicherungen; - der Rückweg dieses Laufs (der neueste) bleibt.""" + der Rückweg dieses Laufs (der neueste) bleibt. Ebenso bleiben Snapshots, die jemand auf der Seite Snapshots per + Knopf angelegt hat (seit 25.09.2026): Die löscht nur der User.""" + from services.homelab import snapshots # snapshots importiert dieses Modul art, behalten = rueckweg or (None, None) gast = inventar.gast(lauf["ziel"]) or {} + per_knopf = snapshots.knopf_namen(lauf["ziel"], gast) for name in gast.get("snapshots") or []: - if name.startswith("mc2-") and name != behalten: + if name.startswith("mc2-") and name != behalten and name not in per_knopf: try: _auftrag(lauf, "snapshot_loeschen", {"vmid": vmid, "snapshot": name}, ZEITLIMIT_KURZ_S) except RuntimeError: diff --git a/backend/tests/test_homelab_snapshots.py b/backend/tests/test_homelab_snapshots.py new file mode 100644 index 0000000..856b542 --- /dev/null +++ b/backend/tests/test_homelab_snapshots.py @@ -0,0 +1,428 @@ +"""Seite Homelab → Snapshots (25.09.2026): Liste je Gerät, Aktionen als Läufe, der Ausführer mit Snapshot-Details. + +Die Snapshots stammen aus dem echten Stand vom 25.09.2026 (pvesh get /nodes/pve/lxc/104/snapshot: nach „Alle +aktualisieren“ lag an jedem Container ein mc2-Snapshot), die Sicherung aus /nodes/pve/storage/local/content.""" + +import importlib.util +import json +import threading +import time +from pathlib import Path + +import pytest +from fastapi import FastAPI +from fastapi.testclient import TestClient +from kern import einstellungen as einstellungen_mod +from services.homelab import inventar, kanal, protokoll, sammellauf, snapshots, updates + +BERICHT = json.loads((Path(__file__).parent / "fixtures" / "pve-bericht.json").read_text(encoding="utf-8")) +AUSFUEHRER = Path(__file__).resolve().parents[2] / "deploy" / "homelab" / "ausfuehrer.py" +UPDATE = "Vor einem Update durch den Homelab Orchestrator" +KNOPF = "Auf Knopfdruck im Homelab Orchestrator angelegt" +GITEA_SNAP = "mc2-20260925-112639" # snaptime 1790328400 = 25.09.2026 11:26:40 +ALT = "local:backup/vzdump-lxc-105-2026_09_25-11_29_57.tar.zst" +NEU = "mc2-20260925-130512" + + +def _ausfuehrer_modul(): + spec = importlib.util.spec_from_file_location("ausfuehrer_snapshots", AUSFUEHRER) + modul = importlib.util.module_from_spec(spec) + spec.loader.exec_module(modul) + return modul + + +# --- Ausführer: Snapshot-Details im Bericht, Anlass beim Anlegen ------------------------------------------------------- + +# pvesh get /nodes/pve/lxc/104/snapshot am 25.09.2026, dazu ein von Hand angelegter (älter, ohne Beschreibung). +PVESH_104 = [ + {"description": UPDATE + "\n", "name": GITEA_SNAP, "snaptime": 1790328400}, + {"description": "You are here!", "digest": "e355", "name": "current", "parent": GITEA_SNAP, "running": 1}, + {"name": "vor-dem-umbau", "snaptime": 1789000000}, +] + + +def test_snapshot_details_aus_pvesh(): + a = _ausfuehrer_modul() + assert a.snapshot_details(PVESH_104) == [ + {"name": "vor-dem-umbau", "zeit": 1789000000, "beschreibung": None, "eigen": False}, + {"name": GITEA_SNAP, "zeit": 1790328400, "beschreibung": UPDATE, "eigen": True}] + assert a.snapshot_details([{"name": "current"}]) == [] and a.snapshot_details(None) == [] + assert a.sicherung_details([{"volid": ALT, "ctime": 1790328597, "size": 360932725, "notes": "mc2-sicherung: …"}]) == [ + {"volid": ALT, "zeit": 1790328597, "groesse": 360932725}] + + +def test_bericht_behaelt_die_namenslisten_und_bringt_details(): + a = _ausfuehrer_modul() + antworten = { + "/nodes/pve/storage": [{"storage": "local", "type": "dir", "content": "backup,iso", "active": 1, "shared": 0, + "avail": 60 * 1024 ** 3}], + "/nodes/pve/storage/local/content": [ + {"volid": ALT, "vmid": 105, "ctime": 1790328597, "size": 360932725, + "notes": "mc2-sicherung: vor einem Update durch den Homelab Orchestrator (proxmox-backup-server)"}, + {"volid": "local:backup/vzdump-lxc-105-2026_09_01-03_00_00.tar.zst", "vmid": 105, "ctime": 1788000000, + "size": 1, "notes": "von Hand"}], + "/cluster/resources": [ + {"vmid": 104, "type": "lxc", "node": "pve", "name": "gitea", "status": "stopped", "tags": "community-script"}, + {"vmid": 105, "type": "lxc", "node": "pve", "name": "proxmox-backup-server", "status": "stopped", + "tags": "backup;community-script"}], + "/nodes/pve/lxc/104/snapshot": PVESH_104, + "/nodes/pve/lxc/105/snapshot": [{"name": "current"}], + "/nodes/pve/lxc/104/config": {"rootfs": "local-lvm:vm-104-disk-0,size=8G"}, + "/nodes/pve/lxc/105/config": {"rootfs": "local-lvm:vm-105-disk-0,size=10G", "mp0": "/mnt/qnap,mp=/mnt/ds"}, + } + + def pvesh(pfad, *parameter): + if pfad not in antworten: + raise RuntimeError(f"pvesh {pfad}: gibt es im Test nicht") + return antworten[pfad] + + a.NODE = "pve" + a._pvesh = pvesh + a._laufen = lambda befehl, zeitlimit=60, sanft=False: (0, "") + gitea, pbs = a.bericht()["gaeste"] + # Die Namensliste bleibt, wie pvesh sie liefert (andere Stellen hängen daran) — die Details kommen dazu. + assert gitea["snapshots"] == [GITEA_SNAP, "vor-dem-umbau"] + assert [d["name"] for d in gitea["snapshot_details"]] == ["vor-dem-umbau", GITEA_SNAP] + assert pbs["sicherungen"] == [ALT] and pbs["snapshots"] == [] and pbs["snapshot_details"] == [] + assert pbs["sicherung_details"] == [{"volid": ALT, "zeit": 1790328597, "groesse": 360932725}] + + +def test_anlegen_mit_festem_anlass(): + a = _ausfuehrer_modul() + a._pvesh = lambda pfad, *p: [{"vmid": 104, "type": "lxc", "tags": "community-script;git"}] + befehle: list[list[str]] = [] + a._laufen = lambda befehl, zeitlimit=60, sanft=False: befehle.append(befehl) or (0, "") + antwort = a.ausfuehren({"aktion": "snapshot", "parameter": {"vmid": 104, "anlass": "knopf"}}) + assert antwort["code"] == 0 and antwort["text"].startswith("snapshot=mc2-") + assert befehle[-1][:3] == ["pct", "snapshot", "104"] and befehle[-1][-2:] == ["--description", KNOPF] + assert a.ausfuehren({"aktion": "snapshot", "parameter": {"vmid": 104}})["code"] == 0 # wie bisher: vor Update + assert befehle[-1][-1] == UPDATE + # Der Server wählt nur aus der Liste; ein freier Text kommt nicht in die Beschreibung. + antwort = a.ausfuehren({"aktion": "snapshot", "parameter": {"vmid": 104, "anlass": "; rm -rf /"}}) + assert antwort["code"] == 2 and "Anlass" in antwort["text"] and len(befehle) == 2 + + +# --- Homelab-Teil: die Liste ----------------------------------------------------------------------------------------- + +def _bericht(**gitea) -> dict: + """Der echte Bericht vom 24.09. mit Snapshots und Sicherungen, wie der Ausführer sie seit dem 25.09. schickt.""" + b = json.loads(json.dumps(BERICHT)) + g = {x["vmid"]: x for x in b["gaeste"]} + g[104].update(snapshots=[GITEA_SNAP, "vor-dem-umbau"], snapshot_details=[ + {"name": "vor-dem-umbau", "zeit": 1789000000, "beschreibung": None, "eigen": False}, + {"name": GITEA_SNAP, "zeit": 1790328400, "beschreibung": UPDATE, "eigen": True}], **gitea) + g[105].update(sicherungen=[ALT], sicherung_details=[{"volid": ALT, "zeit": 1790328597, "groesse": 360932725}], + sicherung_moeglich=True, sicherung_speicher="local", snapshot_details=[]) + g[106].update(snapshots=["docker-vorher"], snapshot_details=[ + {"name": "docker-vorher", "zeit": 1789500000, "beschreibung": "vor dem Umzug", "eigen": False}]) + for x in (100, 101, 102, 103): + g[x]["snapshot_details"] = [] + b["gaeste"].append({"vmid": 107, "art": "lxc", "name": "homelab-orchestrator", "status": "running", + "etiketten": ["mc2"], "erlaubt": False, "snapshots": ["test"]}) + return b + + +@pytest.fixture +def daten(tmp_path, monkeypatch): + monkeypatch.setenv("MC_DATEN_DIR", str(tmp_path)) + monkeypatch.setenv("MC_NOTIFY_LOG", str(tmp_path / "notify.log")) + for name in ("MC_AUSFUEHRER_TOKEN", "MC_WAECHTER_STORE", "MC_ARCANE_KEY"): + monkeypatch.delenv(name, raising=False) + einstellungen_mod.einstellungen.cache_clear() + monkeypatch.setattr(kanal, "_kontakt", {"zuletzt": None}) + monkeypatch.setattr(inventar, "erreichbar", lambda url: True) + monkeypatch.setattr(inventar.karenz, "skript_geaendert", lambda kennung: 0.0) # kein Netz + yield tmp_path + einstellungen_mod.einstellungen.cache_clear() + + +def _geraete(stand: dict) -> dict[str, dict]: + return {g["id"]: g for g in stand["geraete"]} + + +def test_liste_je_geraet_mit_herkunft_und_knoepfen(daten): + kanal.bericht_speichern(_bericht()) + stand = snapshots.liste() + g = _geraete(stand) + assert list(g) == ["ct-100", "ct-101", "ct-102", "ct-103", "ct-104", "ct-105", "vm-106"] # ohne ct-107 + assert stand["details"] is True and stand["sperre"] is None and stand["ausfuehrer"]["verbunden"] is True + assert stand["summe"] == {"snapshots": 3, "eigene": 1, "sicherungen": 1, "sicherungen_groesse": 360932725} + + gitea = g["ct-104"] + assert (gitea["name"], gitea["wo"], gitea["art"], gitea["laeuft"], gitea["grund"]) == ( + "Gitea", "Container 104", "container", None, None) + hand, eigen = gitea["snapshots"] # ältester zuerst + assert (hand["name"], hand["herkunft"], hand["eigen"], hand["loeschen"], hand["zuruecksetzen"]) == ( + "vor-dem-umbau", "proxmox", False, None, None) + assert (eigen["herkunft"], eigen["zeit"], eigen["beschreibung"]) == ("update", 1790328400, UPDATE) + assert eigen["loeschen"]["pfad"] == f"/api/homelab/snapshots/ct-104/{GITEA_SNAP}/loeschen" + assert eigen["loeschen"]["frage"] == ( + f"Den Snapshot {GITEA_SNAP} von Gitea (vom 25.09.2026 11:26, Rückweg eines Updates) endgültig löschen? Am Gerät " + "selbst ändert sich nichts; nur der Weg zurück auf diesen Stand ist danach weg.") + zurueck = eigen["zuruecksetzen"] + assert zurueck["pfad"].endswith(f"/{GITEA_SNAP}/zuruecksetzen") and zurueck["label"] == "Zurücksetzen" + assert zurueck["frage"].startswith(f"Gitea (Container 104) auf den Snapshot vom 25.09.2026 11:26 ({GITEA_SNAP}) " + "zurücksetzen? Alles, was sich seitdem im Container geändert hat") + assert "ist danach verloren" in zurueck["frage"] and "gestoppt und wieder gestartet" in zurueck["frage"] + assert gitea["anlegen"]["pfad"] == "/api/homelab/snapshots/ct-104/anlegen" + assert "Der Container läuft dabei weiter." in gitea["anlegen"]["frage"] + assert "räumt kein Update weg" in gitea["anlegen"]["frage"] + + pbs = g["ct-105"] + assert pbs["anlegen"] is None and pbs["grund"] == ( + "Kein Snapshot möglich: Bind-Mount mp0 (/mnt/qnap-backup/pbs-datastore) — nur Backup möglich. Vor einem Update " + "legt der Orchestrator stattdessen eine Sicherung an.") + (sicherung,) = pbs["sicherungen"] + assert (sicherung["datei"], sicherung["speicher"], sicherung["groesse"]) == ( + "vzdump-lxc-105-2026_09_25-11_29_57.tar.zst", "local", 360932725) + assert sicherung["loeschen"]["pfad"] == ( + "/api/homelab/sicherungen/ct-105/vzdump-lxc-105-2026_09_25-11_29_57.tar.zst/loeschen") + assert "(vom 25.09.2026 11:29, 361 MB, auf „local“)" in sicherung["loeschen"]["frage"] + + # Arcane ohne Etikett (Stand 24.09.): zu sehen, aber ohne Knöpfe. + arcane = g["vm-106"] + assert arcane["anlegen"] is None and arcane["grund"].startswith("Nicht freigegeben") + assert arcane["snapshots"][0]["herkunft"] == "proxmox" and arcane["snapshots"][0]["loeschen"] is None + + +def test_liste_mit_altem_ausfuehrer_nur_aus_namen(daten): + """Bis der neue Ausführer läuft, gibt es nur Namen: der Zeitpunkt aus dem Namen, keine Beschreibung.""" + b = json.loads(json.dumps(BERICHT)) + next(g for g in b["gaeste"] if g["vmid"] == 104)["snapshots"] = [GITEA_SNAP, "vor-dem-umbau"] + next(g for g in b["gaeste"] if g["vmid"] == 105)["sicherungen"] = [ALT] + kanal.bericht_speichern(b) + stand = snapshots.liste() + assert stand["details"] is False + gitea = _geraete(stand)["ct-104"] + assert [(s["name"], s["zeit"], s["beschreibung"]) for s in gitea["snapshots"]] == [ + ("vor-dem-umbau", None, None), (GITEA_SNAP, 1790328399.0, None)] + (sicherung,) = _geraete(stand)["ct-105"]["sicherungen"] + assert sicherung["zeit"] == 1790328597.0 and sicherung["groesse"] is None + + +def test_ohne_bericht_leer(daten): + stand = snapshots.liste() + assert stand["geraete"] == [] and stand["bericht"] is None and stand["ausfuehrer"]["verbunden"] is False + + +# --- Aktionen mit einem nachgespielten Ausführer --------------------------------------------------------------------- + +class Ausfuehrer: + """Beantwortet Aufträge wie der echte und führt einen Bericht, der sich mit ihnen ändert.""" + + def __init__(self, bericht: dict): + self.bericht = bericht + self.auftraege: list[tuple[str, dict]] = [] + self.fehlschlag: dict[str, tuple[int, str]] = {} + self.stopp = threading.Event() + threading.Thread(target=self._laufen, daemon=True).start() + + def gast(self, vmid: int) -> dict: + return next(g for g in self.bericht["gaeste"] if g["vmid"] == vmid) + + def _laufen(self) -> None: + while not self.stopp.is_set(): + a = kanal.naechster() + if not a: + time.sleep(0.02) + continue + aktion, p = a["aktion"], a["parameter"] + self.auftraege.append((aktion, p)) + code, text = self.fehlschlag.get(aktion, (0, "")) + if code == 0 and aktion == "snapshot": + g = self.gast(p["vmid"]) + g["snapshots"].append(NEU) + # Ein Ausführer, der den Anlass noch nicht kennt, schreibt „Vor einem Update …“ hinein. + g["snapshot_details"].append({"name": NEU, "zeit": 1790333112, "beschreibung": UPDATE, "eigen": True}) + text = f"snapshot={NEU}\nfreeze guest filesystem" + elif code == 0 and aktion == "snapshot_loeschen": + g = self.gast(p["vmid"]) + g["snapshots"].remove(p["snapshot"]) + g["snapshot_details"] = [d for d in g["snapshot_details"] if d["name"] != p["snapshot"]] + elif code == 0 and aktion == "sicherung_loeschen": + g = self.gast(p["vmid"]) + g["sicherungen"].remove(p["sicherung"]) + g["sicherung_details"] = [d for d in g["sicherung_details"] if d["volid"] != p["sicherung"]] + elif code == 0 and aktion == "bericht": + text = json.dumps(self.bericht) + kanal.ergebnis(a["id"], code, text) + + +_echtes_warten = kanal.warten + + +@pytest.fixture +def host(daten, monkeypatch): + monkeypatch.setattr(updates, "WARTEN_NACH_UPDATE_S", 0) + monkeypatch.setattr(kanal, "warten", lambda aid, zeitlimit_s, takt_s=2.0: _echtes_warten(aid, min(zeitlimit_s, 10), + 0.02)) + meldungen: list[tuple[str, str]] = [] + monkeypatch.setattr(snapshots.announce, "notify_telegram", lambda betreff, text: meldungen.append((betreff, text))) + verlauf: list[tuple] = [] + monkeypatch.setattr(updates.update_verlauf, "eintragen", lambda *a: verlauf.append(a)) + bericht = _bericht() + kanal.bericht_speichern(bericht) + a = Ausfuehrer(json.loads(json.dumps(bericht))) + a.meldungen, a.verlauf = meldungen, verlauf + yield a + a.stopp.set() + + +def _auf_ende(antwort: dict) -> dict: + assert antwort["ok"], antwort + ende = time.time() + 20 + while time.time() < ende: + lauf = updates.lauf_lesen(antwort["lauf"]) or {} + if lauf.get("status") == "fertig": + return lauf + time.sleep(0.05) + raise AssertionError("Lauf wurde nicht fertig") + + +def test_snapshot_anlegen_ohne_meldung_und_von_keinem_update_weggeraeumt(host): + lauf = _auf_ende(snapshots.anlegen("ct-104")) + assert (lauf["ergebnis"], lauf["baustein"], lauf["snapshot"]) == ("angelegt", "snapshot-anlegen", NEU) + assert lauf["text"] == f"Gitea: Snapshot {NEU} angelegt." + assert host.auftraege == [("snapshot", {"vmid": 104, "anlass": "knopf"}), ("bericht", {})] + assert host.meldungen == [] and host.verlauf == [] # kein Update, keine Meldung bei Erfolg + gitea = _geraete(snapshots.liste())["ct-104"] + neu = next(s for s in gitea["snapshots"] if s["name"] == NEU) + # Der Ausführer schrieb noch „Vor einem Update …“ — der Lauf weiß es besser. + assert neu["herkunft"] == "knopf" and neu["loeschen"]["frage"].count("auf Knopfdruck angelegt") == 1 + assert gitea["zuletzt"] == {"ok": True, "ende": lauf["ende"], "text": f"Gitea: Snapshot {NEU} angelegt."} + assert snapshots.knopf_namen("ct-104", host.gast(104)) == {NEU} + + +def test_gruenes_update_laesst_snapshots_per_knopf_stehen(host): + """Sonst hätte das nächste Update den Snapshot gelöscht, den der User eben selbst angelegt hat.""" + g = host.gast(104) + g["snapshots"] = [GITEA_SNAP, "mc2-20260925-120000", "vor-dem-umbau"] + g["snapshot_details"] = [{"name": "mc2-20260925-120000", "zeit": 1790330400, "beschreibung": KNOPF, "eigen": True}] + g["app"]["version"] = "1.27.3" # der Bericht nach dem Update: neue Version + kanal.bericht_speichern(_bericht()) + lauf = _auf_ende(updates.starten("ct-104", "app")) + assert lauf["ergebnis"] == "eingespielt" + geloescht = [p["snapshot"] for aktion, p in host.auftraege if aktion == "snapshot_loeschen"] + assert geloescht == [GITEA_SNAP] # der per Knopf und der von Hand bleiben + + +def test_snapshot_loeschen_nur_eigene(host): + antwort = snapshots.loeschen("ct-104", "vor-dem-umbau") + assert antwort["ok"] is False and "von Hand angelegte verwaltest du in Proxmox" in antwort["detail"] + assert "gibt es laut dem letzten Bericht nicht" in snapshots.loeschen("ct-104", "mc2-20200101-000000")["detail"] + lauf = _auf_ende(snapshots.loeschen("ct-104", GITEA_SNAP)) + assert (lauf["ergebnis"], lauf["text"]) == ("geloescht", f"Gitea: Snapshot {GITEA_SNAP} gelöscht.") + assert host.auftraege == [("snapshot_loeschen", {"vmid": 104, "snapshot": GITEA_SNAP}), ("bericht", {})] + assert [s["name"] for s in _geraete(snapshots.liste())["ct-104"]["snapshots"]] == ["vor-dem-umbau"] + + +def test_zuruecksetzen_gruen_mit_meldung(host): + lauf = _auf_ende(snapshots.zuruecksetzen("ct-104", GITEA_SNAP)) + assert lauf["ergebnis"] == "zurueckgesetzt" and lauf["zurueckgesetzt"] is True + assert [a for a, _ in host.auftraege] == ["zurueck", "bericht"] + assert host.auftraege[0][1] == {"vmid": 104, "snapshot": GITEA_SNAP} + text = f"Gitea: auf den Snapshot vom 25.09.2026 11:26 ({GITEA_SNAP}) zurückgesetzt, Prüfung grün." + assert host.meldungen == [(snapshots.BETREFF, text)] + assert host.verlauf == [] + + +def test_zuruecksetzen_rot_meldet_dringend(host, monkeypatch): + monkeypatch.setattr(inventar, "erreichbar", lambda url: False) + lauf = _auf_ende(snapshots.zuruecksetzen("ct-104", GITEA_SNAP)) + assert (lauf["ergebnis"], lauf["zurueckgesetzt"], lauf["dringend"]) == ("fehler", True, True) + betreff, text = host.meldungen[-1] + assert betreff == snapshots.BETREFF_ALARM and "zurückgesetzt, aber die Prüfung ist rot" in text + assert "antwortet nicht" in text + eintrag = next(e for e in protokoll.eintraege() if e["art"] == "snapshot") + assert (eintrag["titel"], eintrag["stufe"], eintrag["ziel"]) == ("Zurückgesetzt, Prüfung rot · Gitea", "fehler", + "ct-104") + + +def test_zuruecksetzen_scheitert_und_sagt_wie_es_dem_geraet_geht(host): + host.fehlschlag["zurueck"] = (1, "unable to rollback: snapshot is locked") + lauf = _auf_ende(snapshots.zuruecksetzen("ct-104", GITEA_SNAP)) + assert lauf["ergebnis"] == "fehler" and not lauf.get("zurueckgesetzt") + betreff, text = host.meldungen[-1] + assert betreff == snapshots.BETREFF_ALARM + assert text.startswith(f"Gitea: Zurücksetzen auf den Snapshot vom 25.09.2026 11:26 ({GITEA_SNAP}) gescheitert") + assert "snapshot is locked" in text and text.endswith("Gitea läuft.") + + +def test_sicherung_loeschen(host): + assert "gibt es laut dem letzten Bericht nicht" in snapshots.sicherung_loeschen("ct-105", "x.tar.zst")["detail"] + lauf = _auf_ende(snapshots.sicherung_loeschen("ct-105", "vzdump-lxc-105-2026_09_25-11_29_57.tar.zst")) + assert lauf["ergebnis"] == "geloescht" and host.auftraege[0] == ("sicherung_loeschen", {"vmid": 105, "sicherung": ALT}) + assert _geraete(snapshots.liste())["ct-105"]["sicherungen"] == [] + + +def test_gescheitertes_loeschen_meldet_ohne_alarm(host): + host.fehlschlag["snapshot_loeschen"] = (2, "Abgelehnt: Gast 104 hat kein erlaubtes Etikett") + lauf = _auf_ende(snapshots.loeschen("ct-104", GITEA_SNAP)) + assert lauf["ergebnis"] == "fehler" and host.meldungen[-1][0] == snapshots.BETREFF + assert "ließ sich nicht löschen" in host.meldungen[-1][1] and "kein erlaubtes Etikett" in host.meldungen[-1][1] + assert _geraete(snapshots.liste())["ct-104"]["zuletzt"]["ok"] is False + + +def test_sperren_wie_bei_den_updates(host, monkeypatch): + # Nicht freigegeben, der eigene Container, ein unbekanntes Gerät + assert snapshots.anlegen("vm-106")["detail"].startswith("Dieses Gerät ist nicht freigegeben") + assert snapshots.anlegen("ct-107")["detail"] == "Dieses Gerät steht nicht im Bericht des Ausführers." + assert snapshots.anlegen("ct-999")["ok"] is False + # Kein Snapshot möglich (PBS: Bind-Mount) + assert snapshots.anlegen("ct-105")["detail"].startswith("Kein Snapshot möglich: Bind-Mount mp0") + # Während „Alle aktualisieren“ — die Seite sagt denselben Satz über der Liste. + with monkeypatch.context() as m: + m.setattr(sammellauf, "laeuft", lambda: True) + assert snapshots.anlegen("ct-104")["detail"].startswith(updates.SAMMELLAUF_SPERRE) + assert snapshots.liste()["sperre"] == snapshots.anlegen("ct-104")["detail"] + # Läuft irgendwo ein Update, warten alle Aktionen (sonst stünden sie beim Ausführer hinter ihm an) … + updates._merken({"id": "u1", "ziel": "ct-100", "baustein": "os", "name": "AdGuard Home", "status": "laeuft", + "start": time.time(), "ende": None, "ergebnis": None, "text": None, "schritte": ["os_update …"]}) + assert snapshots.zuruecksetzen("ct-104", GITEA_SNAP)["detail"].startswith( + "Gerade läuft ein Update (AdGuard Home).") + assert _geraete(snapshots.liste())["ct-100"]["laeuft"] == "Update läuft" + updates._merken({**updates.lauf_lesen("u1"), "status": "fertig", "ende": time.time(), "ergebnis": "eingespielt"}) + # … eine Aktion dieser Seite dagegen sperrt nur ihr Gerät; dort lehnen beide Seiten ab. + updates._merken({"id": "x1", "ziel": "ct-104", "baustein": "snapshot-zurueck", "name": "Gitea", "status": "laeuft", + "start": time.time(), "ende": None, "ergebnis": None, "text": None, "schritte": ["zurueck: ok"]}) + assert "läuft gerade schon etwas" in snapshots.loeschen("ct-104", GITEA_SNAP)["detail"] + assert updates.starten("ct-104", "os")["ok"] is False + assert snapshots.liste()["sperre"] is None + assert _geraete(snapshots.liste())["ct-104"]["laeuft"] == "Zurückgesetzt, wird geprüft" + assert "ct-104" in updates.laufende_ziele() # der Wächter lässt das Gerät in Ruhe + # Ausführer im Nur-Lesen-Modus + nur_lesen = _bericht() + nur_lesen["host"]["nur_lesen"] = True + kanal.bericht_speichern(nur_lesen) + assert "Nur-Lesen-Modus" in snapshots.anlegen("ct-102")["detail"] + assert host.auftraege == [] + + +def test_protokoll_und_betreff(host): + _auf_ende(snapshots.anlegen("ct-104")) + _auf_ende(snapshots.zuruecksetzen("ct-104", GITEA_SNAP)) + eintraege = [e for e in protokoll.eintraege() if e["art"] == "snapshot"] + assert [(e["titel"], e["stufe"]) for e in eintraege] == [("Zurückgesetzt, Prüfung grün · Gitea", "ok"), + ("Snapshot angelegt · Gitea", "ok")] + assert eintraege[1]["details"].endswith("Ohne Meldung: Das Ergebnis steht auf der Seite Snapshots.") + # Die Auftrags-Einträge heißen nicht mehr „Alter …“: Gelöscht wird auch von Hand. + assert protokoll._AKTION["snapshot_loeschen"][0] == "Snapshot gelöscht" + bekannt = protokoll._betreffe(updates.laeufe(100), []) + assert bekannt[f"Gitea: auf den Snapshot vom 25.09.2026 11:26 ({GITEA_SNAP}) zurückgesetzt, Prüfung grün."] == ( + snapshots.BETREFF) + + +def test_schnittstelle(host): + from routers import homelab + app = FastAPI() + app.include_router(homelab.router) + c = TestClient(app) + daten = c.get("/api/homelab/snapshots").json() + assert [g["id"] for g in daten["geraete"]][:2] == ["ct-100", "ct-101"] and daten["summe"]["eigene"] == 1 + antwort = c.post("/api/homelab/snapshots/ct-104/vor-dem-umbau/loeschen") + assert antwort.status_code == 409 and "Proxmox" in antwort.json()["detail"] + assert c.post("/api/homelab/sicherungen/ct-105/fremd.tar.zst/loeschen").status_code == 409 + antwort = c.post("/api/homelab/snapshots/ct-102/anlegen") + assert antwort.status_code == 200 and antwort.json()["ok"] is True + lauf = _auf_ende(antwort.json()) + assert lauf["ergebnis"] == "angelegt" and lauf["name"] == "NetBird" diff --git a/backend/tests/test_homelab_speicher.py b/backend/tests/test_homelab_speicher.py index bbbe41e..84567b0 100644 --- a/backend/tests/test_homelab_speicher.py +++ b/backend/tests/test_homelab_speicher.py @@ -168,7 +168,31 @@ def test_empfehlungen_groesster_gewinn_zuerst(): container = tipps[1] assert container["platz"] == (2_076_616_687 - 888_725_504) + (6_442_450_944 - 4_867_121_152) assert "pct fstrim 104 --ignore-mountpoints" in container["text"] and "Gitea 1,6 GB" in container["text"] - assert tipps[2]["titel"] == "Gitea: Snapshot mc2-20260924-192352" and "vom 24.09. 19:23" in tipps[2]["text"] + assert tipps[2]["titel"] == "1 Snapshot des Orchestrators — verwalten unter Homelab → Snapshots" + assert tipps[2]["text"].startswith("Bei Gitea.") and tipps[2]["platz"] is None + + +def test_snapshots_sind_ein_vorschlag(): + """25.09.2026: Nach „Alle aktualisieren“ standen fünf Snapshot-Vorschläge untereinander — jetzt einer, der auf die + Seite Snapshots zeigt. Von Hand angelegte zählen mit, der Container des Orchestrators selbst nicht.""" + b = _bericht() + b["gaeste"][0]["snapshots"] = ["mc2-20260925-112118", "vor-dem-umbau"] + b["gaeste"][1]["snapshots"] = ["mc2-20260924-192352", "mc2-20260925-112639"] + b["gaeste"].append({"vmid": 107, "art": "lxc", "name": "homelab-orchestrator", "etiketten": ["mc2"], + "snapshots": ["test"], "ungenutzt": []}) + tipps = [t for t in speicher.empfehlungen(b) if t["art"] == "snapshot"] + assert len(tipps) == 1 + s = tipps[0] + assert s["titel"] == "3 Snapshots des Orchestrators — verwalten unter Homelab → Snapshots" + assert s["text"].startswith("Bei NetBird und Gitea (2).") + assert "Dazu 1 von Hand in Proxmox angelegt (NetBird)." in s["text"] and "homelab" not in s["text"] + assert s["kurz"] == "4 Snapshots (Homelab → Snapshots)" + b["gaeste"][1]["snapshots"] = [] + b["gaeste"][0]["snapshots"] = ["vor-dem-umbau"] + assert [t["titel"] for t in speicher.empfehlungen(b) if t["art"] == "snapshot"] == [ + "1 von Hand angelegter Snapshot — ansehen unter Homelab → Snapshots"] + b["gaeste"][0]["snapshots"] = [] + assert all(t["art"] != "snapshot" for t in speicher.empfehlungen(b)) def test_kleine_gewinne_sind_keine_empfehlung(): diff --git a/deploy/homelab/ausfuehrer.py b/deploy/homelab/ausfuehrer.py index 6188d62..b43ff9d 100644 --- a/deploy/homelab/ausfuehrer.py +++ b/deploy/homelab/ausfuehrer.py @@ -7,7 +7,10 @@ Container des Homelab-Teils braucht keinen Proxmox-Schlüssel. • Bericht alle 10 Minuten (oder auf Anfrage): Host-Updates, Gäste mit Status, App-Version, OS-Updates, Snapshots und ob ein Snapshot überhaupt geht; wo nicht, ob eine Sicherung - geht, und die Sicherungen des Orchestrators. Nur lesend. + geht, und die Sicherungen des Orchestrators. Nur lesend. Seit 25.09.2026 je Gast auch + snapshot_details (Zeitpunkt, Beschreibung, ob vom Orchestrator) und sicherung_details + (Zeitpunkt, Größe) für die Seite Homelab → Snapshots; die Namenslisten snapshots und + sicherungen bleiben, wie sie waren. • Aufträge eine feste Liste von Aktionen (AKTIONEN); alles andere wird abgelehnt. Welche Gäste angefasst werden dürfen, entscheidet dieser Host selbst anhand der Etiketten: community-script oder watcher, aber nicht watcher-aus. Dem Server wird dabei nicht @@ -55,6 +58,10 @@ ABFRAGE_ALLE_S = 5 ERLAUBT = {"community-script", "watcher"} AUSGENOMMEN = "watcher-aus" SNAPSHOT_NAME = re.compile(r"^mc2-\d{8}-\d{6}$") +# Beschreibung neuer Snapshots in Proxmox (seit 25.09.2026). Der Server wählt nur den Anlass, den Text legt dieser +# Host fest. „knopf“ = „Snapshot anlegen“ auf der Seite Homelab → Snapshots; solche räumt kein Update weg. +SNAPSHOT_ANLASS = {"update": "Vor einem Update durch den Homelab Orchestrator", + "knopf": "Auf Knopfdruck im Homelab Orchestrator angelegt"} # Speicherarten, auf denen Proxmox Snapshots kann. SNAPSHOT_SPEICHER = {"lvmthin", "zfspool", "rbd", "btrfs", "cephfs"} @@ -340,13 +347,43 @@ def _ip_vm(vmid: int) -> str | None: return None -def _snapshots(art: str, vmid: int) -> list[str]: +def _snapshots(art: str, vmid: int) -> list[dict]: + """Die Snapshots eines Gasts, wie pvesh sie liefert (samt „current“, dem laufenden Stand); leer bei Fehlern.""" try: - return [s["name"] for s in _pvesh(f"/nodes/{NODE}/{art}/{vmid}/snapshot") if s.get("name") != "current"] + return [s for s in _pvesh(f"/nodes/{NODE}/{art}/{vmid}/snapshot") or [] if isinstance(s, dict)] except Exception: return [] +def _ganzzahl(wert: object) -> int | None: + try: + return int(wert) + except (TypeError, ValueError): + return None + + +def snapshot_details(eintraege: object) -> list[dict]: + """Die Snapshots für die Seite Homelab → Snapshots, ältester zuerst, ohne „current“: Name, Zeitpunkt (snaptime, + Unix-Sekunden; None, wo Proxmox keinen nennt), Beschreibung und ob er vom Orchestrator ist (nur solche setzt dieser + Host zurück oder löscht er). Eine Belegung steht bewusst nicht dabei: Wie viel ein Snapshot auf LVM-Thin allein + belegt, sagt Proxmox nicht — lvs zählt auch die Blöcke, die er mit dem Original teilt.""" + details = [] + for s in eintraege if isinstance(eintraege, list) else []: + if not isinstance(s, dict) or not s.get("name") or s["name"] == "current": + continue + name = str(s["name"]) + details.append({"name": name, "zeit": _ganzzahl(s.get("snaptime")), + "beschreibung": str(s.get("description") or "").strip() or None, + "eigen": bool(SNAPSHOT_NAME.match(name))}) + return sorted(details, key=lambda d: (d["zeit"] or 0, d["name"])) + + +def sicherung_details(eintraege: list[dict]) -> list[dict]: + """Die eigenen Sicherungen eines Gasts für die Seite Homelab → Snapshots: Archiv, Zeitpunkt (ctime), Größe in Bytes.""" + return [{"volid": e["volid"], "zeit": _ganzzahl(e.get("ctime")), "groesse": _ganzzahl(e.get("size"))} + for e in eintraege] + + def _eigene_sicherungen(speicher: str, vmid: int | None = None) -> list[dict]: parameter = ["--content", "backup"] + (["--vmid", str(vmid)] if vmid is not None else []) return eigene_sicherungen(_pvesh(f"/nodes/{NODE}/storage/{speicher}/content", *parameter), vmid) @@ -579,12 +616,16 @@ def _speicherlage(speicher: list[dict], gaeste: list[dict]) -> dict: return lage -def _gast(eintrag: dict, arten: dict[str, str], sicherung: dict, sicherungen: dict[int, list[str]]) -> dict: +def _gast(eintrag: dict, arten: dict[str, str], sicherung: dict, sicherungen: dict[int, list[dict]]) -> dict: art, vmid = eintrag["type"], int(eintrag["vmid"]) etiketten = _etiketten(eintrag.get("tags")) + snapshots = _snapshots(art, vmid) + eigene = sicherungen.get(vmid, []) gast = {"vmid": vmid, "art": art, "name": eintrag.get("name"), "status": eintrag.get("status"), "etiketten": etiketten, "erlaubt": erlaubt(etiketten), "uptime": eintrag.get("uptime"), - "snapshots": _snapshots(art, vmid), "sicherungen": sicherungen.get(vmid, [])} + "snapshots": [str(s["name"]) for s in snapshots if s.get("name") and s["name"] != "current"], + "snapshot_details": snapshot_details(snapshots), + "sicherungen": [e["volid"] for e in eigene], "sicherung_details": sicherung_details(eigene)} if art == "lxc" and gast["status"] == "running" and eintrag.get("maxdisk"): # Belegung der rootfs (Proxmox liest sie bei laufenden Containern mit). Am 24.09.2026 stand AdGuard bei # 100 % — das Abfrageprotokoll schrieb nicht mehr, die Paketsuche scheiterte, und niemand sah es. @@ -719,11 +760,11 @@ def bericht() -> dict: speicher = _speicher_liste() arten = {s["storage"]: s.get("type") for s in speicher} sicherung = sicherung_stand(speicher, SICHERUNG_SPEICHER) - sicherungen: dict[int, list[str]] = {} + sicherungen: dict[int, list[dict]] = {} if sicherung.get("speicher"): try: for e in _eigene_sicherungen(sicherung["speicher"]): - sicherungen.setdefault(int(SICHERUNG_ARCHIV.match(e["volid"]).group(2)), []).append(e["volid"]) + sicherungen.setdefault(int(SICHERUNG_ARCHIV.match(e["volid"]).group(2)), []).append(e) except Exception: pass gaeste = [] @@ -758,9 +799,11 @@ def _werkzeug(art: str) -> str: def a_snapshot(p: dict) -> tuple[int, str]: art, vmid = _gast_pruefen(p.get("vmid")) + beschreibung = SNAPSHOT_ANLASS.get(str(p.get("anlass") or "update")) + if beschreibung is None: + raise ValueError("unbekannter Anlass für einen Snapshot (update oder knopf)") name = "mc2-" + datetime.now().strftime("%Y%m%d-%H%M%S") - code, text = _laufen([_werkzeug(art), "snapshot", str(vmid), name, "--description", - "Vor einem Update durch den Homelab Orchestrator"], 600) + code, text = _laufen([_werkzeug(art), "snapshot", str(vmid), name, "--description", beschreibung], 600) return code, f"snapshot={name}\n{text}" if code == 0 else text diff --git a/docs/ARCHITEKTUR.md b/docs/ARCHITEKTUR.md index 1708ea6..2382e33 100644 --- a/docs/ARCHITEKTUR.md +++ b/docs/ARCHITEKTUR.md @@ -10,9 +10,9 @@ Abschnitt; der Rest beschreibt vor allem die Rolle `box`. In der Oberfläche sind beide Bereiche getrennt (seit 24.09.): Links steht die Menüführung mit einem Block je Bereich — **KI-Box** (Cockpit `/`, Updates `/updates`, Modelle `/modelle`, dazu Dienste und das Hermes-Dashboard) und -**Homelab** (Cockpit `/homelab`, Updates `/homelab/updates`) —, jeder mit eigener Verbindungsanzeige und der Zahl -offener Updates. Keine Seite zeigt etwas aus dem anderen Bereich. Am Handy steckt dieselbe Leiste hinter dem -Menü-Knopf (`frontend/src/app/Seitenleiste.tsx`, `lib/navigation.ts`). +**Homelab** (Cockpit `/homelab`, Updates `/homelab/updates`, Snapshots `/homelab/snapshots`) —, jeder mit eigener +Verbindungsanzeige und der Zahl offener Updates. Keine Seite zeigt etwas aus dem anderen Bereich. Am Handy steckt +dieselbe Leiste hinter dem Menü-Knopf (`frontend/src/app/Seitenleiste.tsx`, `lib/navigation.ts`). Der Box-Wart hält die KI-Box aktuell, passt auf sie auf und sucht bessere Modelle. Er besteht aus vier eigenen Python-Prozessen, einer Bash-Schicht für Updates, Sicherung und Meldungen und aus Zustandsdateien unter @@ -237,13 +237,17 @@ flowchart LR `snapshot_loeschen`, `sichern`, `sicherung_zurueck`, `sicherung_loeschen`, `host_update`, `host_neustart`) und prüft selbst, ob ein Gast das Etikett `community-script` oder `watcher` trägt und nicht `watcher-aus` — dem Server vertraut er dabei nicht. Seit 24.09. schickt er außerdem jede Minute Messwerte (eigener Faden, siehe „Monitoring“). + `snapshot` nimmt seit 25.09. einen Anlass (`update`, Standard, oder `knopf`) und wählt damit eine feste Beschreibung + („Vor einem Update durch …“ bzw. „Auf Knopfdruck im Homelab Orchestrator angelegt“) — freien Text nimmt er nicht. - **Bericht** (nur lesend, auch von Hand: `python3 ausfuehrer.py --bericht`): Host-Version und Paket-Updates, je Gast Status, IP, Etiketten, Snapshots, ob ein Snapshot geht (Bind-Mounts wie beim PBS verhindern ihn), die Community-Script-Kennung (aus `/usr/bin/update` im Gast), die App-Version (je App eigener Weg: `/root/.`, `AdGuardHome --version`, `netbird version`, `dpkg-query`, Docker-Image-Datum) und die Paket-Updates im Gast samt Alter der Paketlisten. Dazu der Sicherungsspeicher (`host.sicherung`: Name und frei, oder was fehlt), je Container ohne Snapshot, ob eine Sicherung geht (`sicherung_moeglich`, sonst `sicherung_grund`), und die eigenen - Sicherungen je Gast. + Sicherungen je Gast. Seit 25.09. dazu `snapshot_details` (Name, `zeit` = snaptime, Beschreibung, `eigen` = Name + `mc2-…`; ohne Belegung, die kennt Proxmox bei LVM-Thin nicht) und `sicherung_details` (Archiv, `zeit` = ctime, + `groesse`); die Namenslisten `snapshots` und `sicherungen` bleiben unverändert. - **Sicherung statt Snapshot** (Ausführer, seit 24.09.): Wo kein Snapshot geht, sichert `sichern` den Container per `vzdump` — auf den ersten lokalen Speicher, der Sicherungen annimmt (Art `dir`/`btrfs`, nicht geteilt; heute `local` = `/var/lib/vz`), oder auf `sicherung_speicher` aus `/etc/mc2-ausfuehrer.json`. Nie auf einen Speicher der @@ -265,7 +269,8 @@ flowchart LR Warnung in der Rückfrage; scheitert der Schritt, beginnt das Update nicht) → `update` des Community-Scripts (`PHS_SILENT=1`) bzw. Pakete → 20 s warten → frischer Bericht → Prüfung (Gast läuft, Weboberfläche antwortet, App-Version neu). Rot → zurück auf den Snapshot bzw. die Sicherung zurückspielen + dringende Meldung; grün → ältere - `mc2-`-Snapshots bzw. `mc2-sicherung`-Sicherungen dieses Gasts weg (die neueste bleibt) + Meldung. Läufe in + `mc2-`-Snapshots bzw. `mc2-sicherung`-Sicherungen dieses Gasts weg (die neueste bleibt, ebenso per Knopf auf der Seite + Snapshots angelegte: `snapshots.knopf_namen`) + Meldung. Läufe in `/var/lib/mc2/homelab-laeufe.json` und im strukturierten Update-Verlauf. Host: Pakete per Knopf mit Warnung, Neustart als eigener Knopf. - **Wartezeit nach Skriptänderung** (`karenz.py`): `update` lädt `ct/.sh` ungepinnt von GitHub @@ -302,8 +307,8 @@ flowchart LR „unterbrochen (Neustart)“ und meldet es dringend. - **Protokoll** (`protokoll.py`, seit 24.09.): `GET /api/homelab/protokoll?grenze=200&berichte=0` führt zusammen, was geschah, neueste zuerst: Aufträge an den Ausführer (`kanal.py` hebt jetzt die letzten 500 erledigten auf; die - jüngsten 60 mit ganzer Ausgabe, ältere mit den letzten 4000 Zeichen), Update-Läufe mit ihren Schritten, - Sammelläufe, den Verlauf der Hinweise des Wächters (der Verlauf in `mc2-waechter.json` trägt seit 24.09. die Stufe + jüngsten 60 mit ganzer Ausgabe, ältere mit den letzten 4000 Zeichen), Update-Läufe mit ihren Schritten, die Aktionen + der Seite Snapshots (Art `snapshot`, seit 25.09.), Sammelläufe, den Verlauf der Hinweise des Wächters (der Verlauf in `mc2-waechter.json` trägt seit 24.09. die Stufe mit), die Zeilen des Melde-Logs (`MC_NOTIFY_LOG`, im Container `/var/lib/mc2/notify.log`) und die Ereignisse des wöchentlichen Suchens (`homelab-pflege.json`, Liste `ereignisse`). Berichte nur mit `berichte=1`: die Aufträge `bericht` der Läufe und die Berichte, die der Ausführer von sich aus schickt (ihr Eingang steht in @@ -349,19 +354,41 @@ flowchart LR nicht eingebunden oder hängt = rot; eine Sicherung älter als erlaubt (Zeitplan nur mit Uhrzeit = täglich: 26 h, sonst 8 Tage) = gelb, bei allen Geräten oder unerreichbarem Ziel rot. Empfehlungen, größter Gewinn zuerst: Platz, den ein Gast freigegeben hat, der im Pool aber belegt bleibt (VM ohne Discard; Container per `pct fstrim`, - zusammengefasst ab 1 GB), ungenutzte und verwaiste Platten, Snapshots (Größe unbekannt, zuletzt). Seit 25.09. auch + zusammengefasst ab 1 GB), ungenutzte und verwaiste Platten, Snapshots (seit 25.09. ein einziger Vorschlag mit + Verweis auf die Seite Snapshots; Größe unbekannt, zuletzt). Seit 25.09. auch die Systemplatte des Hosts (`host.systemplatte`, `statvfs("/")` wie df) und alte Kernel: `host.kernel_alt` = was `apt-get -s autoremove` entfernen würde, nur Kernel-Pakete, nie laufender, nächster (`kernel_neu`) oder festgepinnter Kernel, mit Größe samt initrd; `host.kernel_bleiben`. Der Vorschlag hat einen Knopf (`POST /api/homelab/ziele/pve/kernel-aufraeumen` → Lauf `kernel` → Ausführer-Aktion `kernel_aufraeumen`, die die Liste selbst neu bestimmt und `apt-get -y purge` ausführt; Ergebnis `aufgeraeumt`). `neustart_noetig` kommt außerdem, wenn ein neuerer Kernel installiert ist als der laufende (Proxmox legt dafür kein reboot-required an). +- **Snapshots verwalten** (`snapshots.py`, seit 25.09., User-Wunsch): `GET /api/homelab/snapshots` liefert je Gerät + (ohne den Container des Orchestrators) die Snapshots mit Zeitpunkt, Beschreibung und Herkunft (`update`, `knopf`, + `proxmox`), die Sicherungen des Orchestrators mit Größe, was gerade läuft (`laeuft`) und das Ergebnis der letzten + Aktion der Seite (6 h lang); Knöpfe samt Rückfrage schickt der Homelab-Teil mit, wie im Ziel-Modell. Ohne + `snapshot_details` (Ausführer vor dem 25.09.) kommt der Zeitpunkt aus dem Namen. Aktionen: + `POST …/snapshots/{id}/anlegen`, `…/snapshots/{id}/{name}/loeschen`, `…/snapshots/{id}/{name}/zuruecksetzen`, + `…/sicherungen/{id}/{datei}/loeschen` — nur freigegebene Gäste, löschen und zurücksetzen nur `mc2-…`, Sicherungen + nur, was der Bericht als eigene nennt; der Ausführer prüft das ohnehin selbst noch einmal. Jede Aktion ist ein Lauf + in `homelab-laeufe.json` (Bausteine `snapshot-anlegen`, `snapshot-loeschen`, `snapshot-zurueck`, + `sicherung-loeschen`) mit denselben Sperren wie „Jetzt updaten“ (`START_SPERRE`, je Gerät einer, + `SAMMELLAUF_SPERRE`), zusätzlich nicht, solange irgendwo ein Update läuft (`_sperre`: Der Ausführer arbeitet einen + Auftrag nach dem anderen ab — hinter einem Update liefe die Aktion in ihr Zeitlimit und käme später unbeobachtet + dran), und nur mit verbundenem Ausführer (nicht im Nur-Lesen-Modus). Abgelehnt wird mit 409; die Liste nennt + denselben Grund (`sperre`). Danach ein frischer Bericht. Zurücksetzen: `zurueck` (stoppt, setzt zurück, startet), + 20 s, Prüfung wie nach einem Update, immer eine Meldung (Betreff „[Homelab-Snapshot]“, bei Fehler oder roter Prüfung + „[Alarm] Homelab-Snapshot“); anlegen und löschen melden nur ihr Scheitern. Nicht im Update-Verlauf, in der + Oberfläche nicht unter „Verlauf“ oder „Zuletzt eingespielt“. Per Knopf angelegte Snapshots erkennt `knopf_namen` an + der Beschreibung oder am Lauf; kein grünes Update räumt sie weg. - **Oberfläche** (Bereich „Homelab“, nur Daten aus `/api/homelab/…`): - **Cockpit** (`/homelab`): oben die Lage wie das Warnpanel der KI-Box — die große Leuchte (Störung vor Hinweis vor laufendem Update vor offenen Updates) und eine Lampe je Gerät —, darunter die Hinweise des Homelab-Wächters und die Geräteliste (App-Version, Paketstand, Erreichbarkeit; „Nach Updates suchen“ nur, wo der Stand unklar ist). - **Updates** (`/homelab/updates`): nur die offenen Updates, eine Zeile je Update mit alter und neuer Version, Rückweg in Kurzform (`rueckweg_art`) und Knopf samt Rückfrage aus dem Ziel-Modell; darunter der Verlauf der Läufe. + - **Snapshots** (`/homelab/snapshots`, seit 25.09.): je Gerät die Snapshots und Sicherungen mit Knöpfen + (`components/homelab/SnapshotListe.tsx`, Texte in `lib/snapshots.ts`); am Handy untereinander, ab `md` die Knöpfe + rechts, ab `xl` fünf Spalten. - Die Logik (Lage, Lampen, Reihenfolge) liegt in `frontend/src/lib/homelab.ts`, die Ansichten in `components/homelab/` und `views/Homelab.tsx`. - **Meldungen** ohne Hermes: `notify.sh` im Container nimmt den Zweitweg direkt an die Bot-API diff --git a/docs/BEDIENUNG.md b/docs/BEDIENUNG.md index 40c7b53..808a22d 100644 --- a/docs/BEDIENUNG.md +++ b/docs/BEDIENUNG.md @@ -18,7 +18,7 @@ hinter dem Menü-Knopf oben links: - **Übersicht** — die Startseite, alles auf einen Blick. - **KI-Box** (Indigo): **Cockpit**, **Updates**, **Modelle**, **Monitoring**, dazu **Dienste und Protokolle** und das Hermes-Dashboard. -- **Homelab** (Violett): **Cockpit**, **Updates**, **Monitoring**, **Protokoll**. +- **Homelab** (Violett): **Cockpit**, **Updates**, **Snapshots**, **Monitoring**, **Protokoll**. - Ganz unten die **Einstellungen**. Jeder Bereich zeigt oben, ob er online ist, und neben „Updates“ die Zahl der Updates, die bereitstehen. Frühere @@ -116,7 +116,9 @@ Werte zu jedem Zeitpunkt; „Werte als Tabelle“ klappt die letzten Punkte als Platz bringt“: Vorschläge mit ungefährem Gewinn, dem Ort und dem Klickweg in Proxmox, größter zuerst; aufgeklappt, sobald Pool oder Systemplatte knapp werden. Gelöscht wird nichts von selbst — nur alte Kernel haben einen Knopf („Alte Kernel entfernen“, mit Rückfrage): Entfernt wird, was Proxmox selbst für entbehrlich hält, nie der laufende - oder der Kernel für den nächsten Start; die Gäste laufen weiter. + oder der Kernel für den nächsten Start; die Gäste laufen weiter. Alle Snapshots stehen dort seit 25.09. als **ein** + Vorschlag („5 Snapshots des Orchestrators — verwalten unter Homelab → Snapshots“) mit dem Verweis „Zu den + Snapshots“. ## Homelab · Updates @@ -136,6 +138,29 @@ Werte zu jedem Zeitpunkt; „Werte als Tabelle“ klappt die letzten Punkte als bleibt stehen. Während des Laufs zeigt ein Kasten jeden Schritt mit Zustand; am Ende kommt eine Nachricht. - **Verlauf:** die letzten Updates im Homelab mit Ergebnis. +## Homelab · Snapshots + +Seit 25.09. Je Gerät (die Container und die Arcane-VM) seine Snapshots, beim Proxmox Backup Server die Sicherungen, +die der Orchestrator dort vor Updates anlegt (ein Snapshot geht beim PBS nicht). + +- **Eine Zeile je Snapshot:** Name, Herkunft („vor Update“ = Rückweg eines Updates, „per Knopf“ = hier angelegt, + „von Hand“ = in Proxmox angelegt), Zeitpunkt und Alter, die Beschreibung aus Proxmox. Wie viel ein Snapshot im + Speicherpool belegt, sagt Proxmox nicht; er wächst mit jeder Änderung seit seinem Zeitpunkt. +- **Snapshot anlegen:** legt sofort einen an, das Gerät läuft dabei weiter. So angelegte räumt kein Update weg — sie + bleiben, bis du sie löschst. Wo keiner geht (PBS) oder das Gerät nicht freigegeben ist (Etikett „watcher“ fehlt), + steht der Grund statt des Knopfs. +- **Zurücksetzen:** setzt das Gerät auf diesen Snapshot zurück. Alles, was sich seitdem darin geändert hat, ist danach + weg; das Gerät wird gestoppt und wieder gestartet und ist ein paar Minuten nicht erreichbar. Danach prüft der + Orchestrator, ob es wieder antwortet, und schickt eine Nachricht (dringend, wenn nicht). Die Rückfrage sagt das + vorher; wer den jetzigen Stand behalten will, legt vorher einen Snapshot an. +- **Löschen:** löscht einen Snapshot oder eine Sicherung des Orchestrators endgültig; am Gerät selbst ändert sich + nichts. Von Hand angelegte Snapshots lassen sich hier nur ansehen, gelöscht werden sie in Proxmox. +- Während etwas läuft, steht beim Gerät „Läuft: …“, danach das Ergebnis. Eine Nachricht kommt beim Zurücksetzen immer, + beim Anlegen und Löschen nur, wenn es scheitert. Solange irgendwo ein Update oder „Alle aktualisieren“ läuft oder der + Ausführer schweigt, ruhen die Knöpfe, und oben steht warum: Der Ausführer erledigt einen Auftrag nach dem anderen. +- Nach einem grünen Update räumt der Orchestrator ältere Rückwege dieses Geräts selbst weg — nicht die per Knopf + angelegten. + ## Homelab · Monitoring Wie beim Monitoring der KI-Box: Zeitraum oben, darunter der Proxmox-Host (CPU, Speicher, Temperatur, Systemplatte, @@ -144,7 +169,8 @@ Netz) und für jeden Gast CPU und Speicher. Die Werte kommen jede Minute vom Aus ## Homelab · Protokoll Was der Homelab-Teil getan hat, neueste zuerst und nach Tagen: Aufträge an den Ausführer (Snapshot, Update, Suche …), -Update-Läufe, Hinweise des Wächters, gesendete Meldungen und die nächtliche Paketsuche. Oben filterst du nach Art; +Update-Läufe, was auf der Seite Snapshots geschah, Hinweise des Wächters, gesendete Meldungen und die nächtliche +Paketsuche. Oben filterst du nach Art; „Berichte zeigen“ blendet auch die Berichte ein, die alle zehn Minuten kommen. „Ausgabe zeigen“ klappt die Ausgabe eines Auftrags auf. diff --git a/frontend/src/app/router.tsx b/frontend/src/app/router.tsx index fab85fb..00c49ce 100644 --- a/frontend/src/app/router.tsx +++ b/frontend/src/app/router.tsx @@ -41,6 +41,10 @@ const homelabUpdates = createRoute({ getParentRoute: () => wurzel, path: "/homelab/updates", component: lazyRouteComponent(() => import("@/views/Homelab"), "HomelabUpdatesSeite"), }) +const homelabSnapshots = createRoute({ + getParentRoute: () => wurzel, path: "/homelab/snapshots", + component: lazyRouteComponent(() => import("@/views/HomelabSnapshots"), "HomelabSnapshotsSeite"), +}) const homelabMonitoring = createRoute({ getParentRoute: () => wurzel, path: "/homelab/monitoring", component: lazyRouteComponent(() => import("@/views/Monitoring"), "HomelabMonitoringSeite"), @@ -75,6 +79,7 @@ export const router = createRouter({ routeTree: wurzel.addChildren([ uebersicht, box, boxUpdates, boxModelle, boxMonitoring, homelab, homelabUpdates, homelabMonitoring, homelabProtokoll, einstellungen, altUpdates, altModelle, + homelabSnapshots, ]), defaultPreload: "intent", defaultErrorComponent: Absturz, diff --git a/frontend/src/components/homelab/SnapshotListe.test.tsx b/frontend/src/components/homelab/SnapshotListe.test.tsx new file mode 100644 index 0000000..1c80d58 --- /dev/null +++ b/frontend/src/components/homelab/SnapshotListe.test.tsx @@ -0,0 +1,135 @@ +import { fireEvent, render, screen, within } from "@testing-library/react" +import type { HomelabSnapshots, SnapshotGeraet, ZielAktion } from "@/lib/typen" +import { SnapshotListe } from "./SnapshotListe" + +// Der Stand vom 25.09.2026 13:40: Gitea mit dem Rückweg des Updates von 11:26 und einem von Hand angelegten Snapshot, +// der PBS mit seiner Sicherung (kein Snapshot möglich), Arcane ohne Freigabe, NetBird mitten im Anlegen. +const JETZT = 1_790_334_000 +const aktion = (pfad: string, label: string, frage: string): ZielAktion => ({ methode: "POST", pfad, label, frage }) + +const ZURUECK = aktion("/api/homelab/snapshots/ct-104/mc2-20260925-112639/zuruecksetzen", "Zurücksetzen", + "Gitea (Container 104) auf den Snapshot vom 25.09.2026 11:26 (mc2-20260925-112639) zurücksetzen? Alles, was sich " + + "seitdem im Container geändert hat — Daten, Einstellungen, Updates —, ist danach verloren.") +const LOESCHEN = aktion("/api/homelab/snapshots/ct-104/mc2-20260925-112639/loeschen", "Snapshot löschen", + "Den Snapshot mc2-20260925-112639 von Gitea (vom 25.09.2026 11:26, Rückweg eines Updates) endgültig löschen?") +const ANLEGEN = aktion("/api/homelab/snapshots/ct-104/anlegen", "Snapshot anlegen", + "Jetzt einen Snapshot von Gitea (Container 104) anlegen? Der Container läuft dabei weiter.") +const SICHERUNG_WEG = aktion("/api/homelab/sicherungen/ct-105/vzdump-lxc-105-2026_09_25-11_29_57.tar.zst/loeschen", + "Sicherung löschen", "Die Sicherung vzdump-lxc-105-2026_09_25-11_29_57.tar.zst von Proxmox Backup Server … löschen?") + +const basis = { vmid: 0, art: "container" as const, status: "running", erlaubt: true, anlegen: null, grund: null, + laeuft: null, zuletzt: null, snapshots: [], sicherungen: [] } + +const gitea: SnapshotGeraet = { + ...basis, id: "ct-104", vmid: 104, name: "Gitea", wo: "Container 104", anlegen: ANLEGEN, + zuletzt: { ok: true, ende: JETZT - 600, text: "Gitea: Snapshot mc2-20260925-112639 gelöscht." }, + snapshots: [ + { name: "vor-dem-umbau", zeit: 1_789_000_000, beschreibung: null, herkunft: "proxmox", eigen: false, + loeschen: null, zuruecksetzen: null }, + { name: "mc2-20260925-112639", zeit: 1_790_328_400, beschreibung: "Vor einem Update durch den Homelab Orchestrator", + herkunft: "update", eigen: true, loeschen: LOESCHEN, zuruecksetzen: ZURUECK }, + ], +} +const pbs: SnapshotGeraet = { + ...basis, id: "ct-105", vmid: 105, name: "Proxmox Backup Server", wo: "Container 105", + grund: "Kein Snapshot möglich: Bind-Mount mp0 (/mnt/qnap-backup/pbs-datastore) — nur Backup möglich.", + sicherungen: [{ datei: "vzdump-lxc-105-2026_09_25-11_29_57.tar.zst", speicher: "local", zeit: 1_790_328_597, + groesse: 360_932_725, loeschen: SICHERUNG_WEG }], +} +const arcane: SnapshotGeraet = { + ...basis, id: "vm-106", vmid: 106, art: "vm", name: "Arcane (Docker)", wo: "VM 106", erlaubt: false, + grund: "Nicht freigegeben: Das Etikett „watcher“ fehlt.", + snapshots: [{ name: "mc2-20260920-100000", zeit: 1_789_891_200, beschreibung: null, herkunft: "update", eigen: true, + loeschen: null, zuruecksetzen: null }], +} +const netbird: SnapshotGeraet = { + ...basis, id: "ct-102", vmid: 102, name: "NetBird", wo: "Container 102", laeuft: "Snapshot wird angelegt", + anlegen: aktion("/api/homelab/snapshots/ct-102/anlegen", "Snapshot anlegen", "…"), + snapshots: [{ ...gitea.snapshots[1], name: "mc2-20260925-112118", + loeschen: aktion("/x/loeschen", "Snapshot löschen", "…"), zuruecksetzen: aktion("/x/z", "Zurücksetzen", "…") }], +} +const adguard: SnapshotGeraet = { ...basis, id: "ct-100", vmid: 100, name: "AdGuard Home", wo: "Container 100", + anlegen: aktion("/api/homelab/snapshots/ct-100/anlegen", "Snapshot anlegen", "…") } + +const daten: HomelabSnapshots = { + jetzt: JETZT, bericht: { empfangen: JETZT - 60, veraltet: false }, + ausfuehrer: { verbunden: true, zuletzt: JETZT - 60, nur_lesen: false }, sperre: null, details: true, + geraete: [adguard, netbird, gitea, pbs, arcane], + summe: { snapshots: 4, eigene: 3, sicherungen: 1, sicherungen_groesse: 360_932_725 }, +} + +const bereich = (name: string) => screen.getByRole("region", { name }) +const zeile = (name: string) => screen.getByRole("rowheader", { name }).closest("[role=row]") as HTMLElement + +describe("SnapshotListe", () => { + it("zeigt je Gerät Name, Herkunft, Zeitpunkt, Alter und Beschreibung", () => { + render( {}} />) + const eigen = zeile("mc2-20260925-112639") + expect(within(eigen).getByText("vor Update")).toBeInTheDocument() + expect(within(eigen).getByText("HEUTE 11:26")).toBeInTheDocument() + expect(within(eigen).getByText("vor 2 h")).toBeInTheDocument() + expect(within(eigen).getByText("Vor einem Update durch den Homelab Orchestrator")).toBeInTheDocument() + // Von Hand angelegt: nur zur Ansicht, mit dem Grund statt Knöpfen. + const hand = zeile("vor-dem-umbau") + expect(within(hand).getByText("von Hand")).toBeInTheDocument() + expect(within(hand).getByText("10.09. 02:26")).toBeInTheDocument() + expect(within(hand).getByText("Nur in Proxmox")).toBeInTheDocument() + expect(within(hand).queryByRole("button")).not.toBeInTheDocument() + // Gerät ohne Snapshots + expect(within(bereich("AdGuard Home")).getByText("Keine Snapshots.")).toBeInTheDocument() + // Das Ergebnis der letzten Aktion steht beim Gerät, ohne seinen Namen noch einmal. + expect(within(bereich("Gitea")).getByText("Snapshot mc2-20260925-112639 gelöscht.")).toBeInTheDocument() + }) + + it("fragt vor dem Zurücksetzen mit dem Text des Homelab-Teils", () => { + const start = vi.fn() + render() + fireEvent.click(within(zeile("mc2-20260925-112639")).getByRole("button", { name: "Zurücksetzen" })) + const dialog = screen.getByRole("dialog") + expect(within(dialog).getByText("Gitea: Zurücksetzen")).toBeInTheDocument() + expect(within(dialog).getByText(/ist danach verloren/)).toBeInTheDocument() + expect(start).not.toHaveBeenCalled() + fireEvent.click(within(dialog).getByRole("button", { name: "Zurücksetzen" })) + expect(start).toHaveBeenCalledWith(ZURUECK) + }) + + it("legt nach Rückfrage einen Snapshot an und löscht eine Sicherung", () => { + const start = vi.fn() + render() + fireEvent.click(within(bereich("Gitea")).getByRole("button", { name: "Snapshot anlegen" })) + fireEvent.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Snapshot anlegen" })) + expect(start).toHaveBeenLastCalledWith(ANLEGEN) + + const sicherung = zeile("vzdump-lxc-105-2026_09_25-11_29_57.tar.zst") + expect(within(sicherung).getByText("Sicherung")).toBeInTheDocument() + expect(within(sicherung).getByText("361 MB auf „local“, vor einem Update angelegt")).toBeInTheDocument() + fireEvent.click(within(sicherung).getByRole("button", { name: "Löschen" })) + fireEvent.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Sicherung löschen" })) + expect(start).toHaveBeenLastCalledWith(SICHERUNG_WEG) + }) + + it("sagt, warum es keinen Knopf gibt", () => { + render( {}} />) + const p = bereich("Proxmox Backup Server") + expect(within(p).getByText(/Kein Snapshot möglich: Bind-Mount mp0/)).toBeInTheDocument() + expect(within(p).queryByRole("button", { name: "Snapshot anlegen" })).not.toBeInTheDocument() + const a = bereich("Arcane (Docker)") + expect(within(a).getByText(/Nicht freigegeben: Das Etikett/)).toBeInTheDocument() + expect(within(a).getByText("Nicht freigegeben")).toBeInTheDocument() // eigener Snapshot, aber kein Knopf + expect(within(a).queryByRole("button")).not.toBeInTheDocument() + }) + + it("zeigt „Läuft: …“ statt des Knopfs und sperrt die übrigen Knöpfe des Geräts", () => { + render( {}} />) + const n = bereich("NetBird") + expect(within(n).getByRole("status")).toHaveTextContent("Läuft: Snapshot wird angelegt …") + expect(within(n).queryByRole("button", { name: "Snapshot anlegen" })).not.toBeInTheDocument() + expect(within(n).getByRole("button", { name: "Löschen" })).toBeDisabled() + expect(within(bereich("Gitea")).getByRole("button", { name: "Löschen" })).toBeEnabled() + }) + + it("sperrt alles, solange es die Seite sagt", () => { + render( {}} />) + for (const knopf of screen.getAllByRole("button")) expect(knopf).toBeDisabled() + }) +}) diff --git a/frontend/src/components/homelab/SnapshotListe.tsx b/frontend/src/components/homelab/SnapshotListe.tsx new file mode 100644 index 0000000..8c4090c --- /dev/null +++ b/frontend/src/components/homelab/SnapshotListe.tsx @@ -0,0 +1,209 @@ +import { type ReactNode, useState } from "react" +import { CircleCheck, CircleX, Plus, Trash2, Undo2 } from "lucide-react" +import { cn } from "cn" +import { Bestaetigen } from "@/components/cockpit/Bestaetigen" +import { Chip } from "@/components/cockpit/Chip" +import { Button } from "@/components/ui/button" +import { alterText, groesseText, HERKUNFT, zeitpunktText, zuletztText } from "@/lib/snapshots" +import type { + HomelabSicherungsArchiv, HomelabSnapshot, HomelabSnapshots, SnapshotGeraet, ZielAktion, +} from "@/lib/typen" + +type Frage = { name: string; aktion: ZielAktion; gefahr: boolean } | null + +// Eine Zeile je Snapshot bzw. Sicherung: Name, Herkunft, Zeitpunkt, Beschreibung, Knöpfe — in drei Anordnungen: +// Handy Name und Herkunft oben, darunter Zeitpunkt, Beschreibung und die Knöpfe nebeneinander +// ab md links Name, Zeitpunkt, Beschreibung untereinander, rechts die Knöpfe übereinander +// ab xl alles in einer Zeile; die Knöpfe haben eine feste Breite, damit die Spalten fluchten +// (Fünf Spalten schon ab md drückten den Namen bei 1024 px auf 77 px.) +const ZEILE = + "grid grid-cols-[minmax(0,1fr)_auto] items-start gap-x-3 gap-y-1.5 border-t border-linie py-3 " + + "[grid-template-areas:'name_herkunft'_'zeit_zeit'_'text_text'_'knoepfe_knoepfe'] " + + "md:grid-rows-[auto_auto_1fr] md:gap-x-4 md:[grid-template-areas:'name_herkunft'_'zeit_knoepfe'_'text_knoepfe'] " + + "xl:grid-cols-[minmax(10.5rem,1.1fr)_7.5rem_minmax(0,1fr)_minmax(0,1.4fr)_11rem] xl:grid-rows-none xl:items-center " + + "xl:[grid-template-areas:'name_herkunft_zeit_text_knoepfe']" +// Namen brechen an ihren Bindestrichen (mc2-20260925- | 113700), nicht mitten in der Zahl. +const NAME = "ziffern min-w-0 pt-1 text-sm break-words text-foreground [grid-area:name] xl:pt-0" +const HERKUNFT_ZELLE = "justify-self-end [grid-area:herkunft] xl:justify-self-start" + +function Zeitpunkt({ zeit, jetzt }: { zeit: number | null; jetzt: number }) { + return ( + + {zeitpunktText(zeit, jetzt)} + {zeit !== null && {alterText(zeit, jetzt)}} + + ) +} + +function Beschreibung({ children }: { children: ReactNode }) { + return {children} +} + +function Knoepfe({ children, ohne }: { children: ReactNode; ohne: string | null }) { + return ( + + {ohne ? {ohne} : children} + + ) +} + +function SnapshotZeile({ g, s, jetzt, gesperrt, onFrage }: { + g: SnapshotGeraet + s: HomelabSnapshot + jetzt: number + gesperrt: boolean + onFrage: (f: Frage) => void +}) { + const { loeschen, zuruecksetzen } = s + const ohne = loeschen || zuruecksetzen ? null : s.eigen ? "Nicht freigegeben" : "Nur in Proxmox" + return ( +
+ {s.name} + + {HERKUNFT[s.herkunft].chip} + + + {s.beschreibung ?? {HERKUNFT[s.herkunft].text}} + + {zuruecksetzen && ( + + )} + {loeschen && ( + + )} + +
+ ) +} + +function SicherungZeile({ g, e, jetzt, gesperrt, onFrage }: { + g: SnapshotGeraet + e: HomelabSicherungsArchiv + jetzt: number + gesperrt: boolean + onFrage: (f: Frage) => void +}) { + const groesse = groesseText(e.groesse) + const loeschen = e.loeschen + return ( +
+ {e.datei} + Sicherung + + + {groesse ? `${groesse} auf „${e.speicher}“` : `Auf „${e.speicher}“`}, vor einem Update angelegt + + + {loeschen && ( + + )} + +
+ ) +} + +function Geraet({ g, jetzt, gesperrt, onFrage }: { + g: SnapshotGeraet + jetzt: number + gesperrt: boolean + onFrage: (f: Frage) => void +}) { + const leer = g.snapshots.length === 0 && g.sicherungen.length === 0 + const anlegen = g.anlegen + return ( +
+
+
+

{g.name}

+ {g.wo} +
+ {g.laeuft ? ( +

Läuft: {g.laeuft} …

+ ) : ( + anlegen && ( + + ) + )} +
+ {g.grund &&

{g.grund}

} + {g.zuletzt && ( +

+ {g.zuletzt.ok + ? + : } + + {zuletztText(g.zuletzt.text, g.name)} + {zeitpunktText(g.zuletzt.ende, jetzt)} + +

+ )} + {leer ? ( +

Keine Snapshots.

+ ) : ( +
+
+ Snapshot + Herkunft + Zeitpunkt + Beschreibung + Aktion +
+ {g.snapshots.map((s) => ( + + ))} + {g.sicherungen.map((e) => ( + + ))} +
+ )} +
+ ) +} + +/** + * Snapshots und Sicherungen je Gerät. Knöpfe gibt es nur, wo der Homelab-Teil eine Aktion mitschickt (Snapshots des + * Orchestrators, freigegebene Geräte); jede fragt vorher mit dem Text des Homelab-Teils. Läuft für ein Gerät etwas, + * steht „Läuft: …“ statt des Knopfs, und seine übrigen Knöpfe ruhen. + */ +export function SnapshotListe({ daten, gesperrt, onAktion }: { + daten: HomelabSnapshots + gesperrt: boolean + onAktion: (a: ZielAktion) => void +}) { + const [frage, setFrage] = useState(null) + return ( + <> +
+ {daten.geraete.map((g) => ( + + ))} +
+ { + if (frage) onAktion(frage.aktion) + setFrage(null) + }} + onNein={() => setFrage(null)} + /> + + ) +} diff --git a/frontend/src/components/homelab/Speicher.test.tsx b/frontend/src/components/homelab/Speicher.test.tsx index 78ca1f4..7e90a92 100644 --- a/frontend/src/components/homelab/Speicher.test.tsx +++ b/frontend/src/components/homelab/Speicher.test.tsx @@ -47,6 +47,13 @@ describe("Speicher", () => { expect(screen.getByText("fast voll")).toBeInTheDocument() }) + it("verweist beim Vorschlag zu den Snapshots auf deren Seite (seit 25.09.2026)", () => { + render(Zu den Snapshots} />) + const links = screen.getAllByRole("link", { name: "Zu den Snapshots" }) + expect(links).toHaveLength(1) + expect(links[0].closest("li")).toHaveTextContent("Gitea: Snapshot mc2-20260924-192352") + }) + it("nennt Störungen des NAS und fehlende Sicherungen", () => { render( void + /** Verweis auf die Seite Snapshots, beim Vorschlag zu den Snapshots (seit 25.09.2026; die Seite reicht ihn herein). */ + snapshotsLink?: ReactNode }) { const [frage, setFrage] = useState(null) const knapp = daten.pools.some((p) => p.stufe !== "ok") || (daten.systemplatte?.stufe ?? "ok") !== "ok" @@ -175,7 +177,8 @@ export function Speicher({ daten, laeuft = null, gesperrt = false, onAktion }: {
    {daten.empfehlungen.map((e) => ( - + ))}
@@ -211,11 +214,12 @@ function MitBefehlen({ text }: { text: string }) { ) } -function Vorschlag({ e, laeuft, gesperrt, onFrage }: { +function Vorschlag({ e, laeuft, gesperrt, onFrage, verweis }: { e: SpeicherEmpfehlung laeuft: string | null gesperrt: boolean onFrage: (a: ZielAktion) => void + verweis?: ReactNode }) { return (
  • @@ -225,6 +229,7 @@ function Vorschlag({ e, laeuft, gesperrt, onFrage }: { {e.ort && {ORT[e.ort] ?? e.ort}}

    + {verweis} {e.aktion && (laeuft ? (

    Läuft: {laeuft}

    ) : ( diff --git a/frontend/src/lib/abfragen.ts b/frontend/src/lib/abfragen.ts index 8ea672d..75a5073 100644 --- a/frontend/src/lib/abfragen.ts +++ b/frontend/src/lib/abfragen.ts @@ -14,6 +14,7 @@ import type { ProtokollEintrag, Radar, SammelPlanSchritt, Sammellauf, Sicherung, Start, TelegramTest, UpdateDetails, ZielAktion, ZielStand, Zeitraum, } from "./typen" +import type { HomelabSnapshots } from "./typen" import { gbText } from "./zeit" const takt = (ms: number) => () => (stromVerbunden() ? ms * 5 : ms) @@ -448,6 +449,27 @@ export const useHomelabSpeicher = (aktiv: boolean) => retry: false, }) +/** + * Snapshots und Sicherungen je Gerät (Seite Homelab → Snapshots, seit 25.09.2026). Der Schlüssel beginnt mit + * „homelab“: Wer „homelab“ neu lädt (Live-Strom nach einem neuen Bericht, die Update-Knöpfe), lädt diese Liste mit. + * Läuft für ein Gerät etwas, alle 3 s nachsehen. + */ +export const useHomelabSnapshots = (aktiv: boolean) => + useQuery({ + queryKey: ["homelab", "snapshots"], + queryFn: () => api("/api/homelab/snapshots"), + enabled: aktiv, + refetchInterval: (q) => (q.state.data?.geraete.some((g) => g.laeuft) ? 3000 : 30_000), + retry: false, + }) + +/** Knöpfe der Seite Snapshots: Pfad und Rückfrage liefert der Homelab-Teil mit der Liste. */ +export const useSnapshotAktion = () => + useAktion((a: ZielAktion) => api(a.pfad, { method: a.methode }), { + erfolg: (a) => `${a.label}: gestartet. Das Ergebnis steht gleich beim Gerät.`, + neuLaden: ["homelab", "homelab-laeufe"], + }) + export const useHomelabEinstellungen = (aktiv: boolean) => useQuery({ queryKey: ["homelab-einstellungen"], diff --git a/frontend/src/lib/navigation.ts b/frontend/src/lib/navigation.ts index 774b74e..42eecb3 100644 --- a/frontend/src/lib/navigation.ts +++ b/frontend/src/lib/navigation.ts @@ -2,6 +2,7 @@ import { useRouterState } from "@tanstack/react-router" import { Activity, Cpu, Gauge, LayoutGrid, type LucideIcon, RefreshCw, ScrollText, Settings, } from "lucide-react" +import { History } from "lucide-react" import { useBoxZiele, useHomelab, useInstanz, usePartner } from "@/lib/abfragen" import { offeneUpdates } from "@/lib/homelab" import { useStromLage } from "@/lib/strom" @@ -20,6 +21,7 @@ export const BEREICHE: { id: Bereich; name: string }[] = [ export type SeitenPfad = | "/" | "/box" | "/box/updates" | "/box/modelle" | "/box/monitoring" | "/homelab" | "/homelab/updates" | "/homelab/monitoring" | "/homelab/protokoll" | "/einstellungen" + | "/homelab/snapshots" export interface Seite { to: SeitenPfad @@ -38,6 +40,8 @@ export const SEITEN: Seite[] = [ { to: "/box/monitoring", label: "Monitoring", Icon: Activity, ort: "box" }, { to: "/homelab", label: "Cockpit", Icon: Gauge, ort: "homelab" }, { to: "/homelab/updates", label: "Updates", Icon: RefreshCw, ort: "homelab", zaehlt: true }, + // Nach „Updates“: Snapshots sind der Rückweg der Updates (seit 25.09.2026). + { to: "/homelab/snapshots", label: "Snapshots", Icon: History, ort: "homelab" }, { to: "/homelab/monitoring", label: "Monitoring", Icon: Activity, ort: "homelab" }, { to: "/homelab/protokoll", label: "Protokoll", Icon: ScrollText, ort: "homelab" }, { to: "/einstellungen", label: "Einstellungen", Icon: Settings, ort: "system" }, diff --git a/frontend/src/lib/snapshots.test.ts b/frontend/src/lib/snapshots.test.ts new file mode 100644 index 0000000..bcf852a --- /dev/null +++ b/frontend/src/lib/snapshots.test.ts @@ -0,0 +1,39 @@ +import { alterText, groesseText, istSnapshotLauf, summeText, zeitpunktText, zuletztText } from "@/lib/snapshots" + +// 25.09.2026 13:40 in Berlin — der Snapshot von Gitea ist von 11:26 desselben Tages. +const JETZT = 1_790_334_000 + +describe("Snapshot-Texte", () => { + it("nennt Zeitpunkt und Alter nach der Uhr des Homelab-Teils", () => { + expect(zeitpunktText(1_790_328_400, JETZT)).toBe("HEUTE 11:26") + expect(alterText(1_790_328_400, JETZT)).toBe("vor 2 h") + expect(zeitpunktText(1_789_000_000, JETZT)).toBe("10.09. 02:26") + expect(alterText(1_789_000_000, JETZT)).toBe("vor 15 Tagen") + expect(zeitpunktText(null, JETZT)).toBe("Zeitpunkt unbekannt") + expect(alterText(null, JETZT)).toBe("") + }) + + it("rechnet Sicherungen unter einem GB in MB", () => { + expect(groesseText(360_932_725)).toBe("361 MB") + expect(groesseText(1_234_000_000)).toBe("1,2 GB") + expect(groesseText(null)).toBeNull() + }) + + it("zählt oben rechts und lässt fehlende Sicherungen weg", () => { + expect(summeText({ snapshots: 3, eigene: 1, sicherungen: 1, sicherungen_groesse: 1 })).toBe("3 Snapshots · 1 Sicherung") + expect(summeText({ snapshots: 1, eigene: 1, sicherungen: 0, sicherungen_groesse: null })).toBe("1 Snapshot") + }) + + it("trennt Snapshot-Aktionen von Updates", () => { + expect(istSnapshotLauf({ baustein: "snapshot-zurueck" })).toBe(true) + expect(istSnapshotLauf({ baustein: "sicherung-loeschen" })).toBe(true) + expect(istSnapshotLauf({ baustein: "app" })).toBe(false) + expect(istSnapshotLauf({ baustein: "kernel" })).toBe(false) + }) + + it("nimmt den Gerätenamen aus dem Ergebnis, das ja beim Gerät steht", () => { + expect(zuletztText("Gitea: auf den Snapshot vom 25.09.2026 11:26 zurückgesetzt, Prüfung grün.", "Gitea")) + .toBe("Auf den Snapshot vom 25.09.2026 11:26 zurückgesetzt, Prüfung grün.") + expect(zuletztText("Snapshot anlegen unterbrochen: …", "Gitea")).toBe("Snapshot anlegen unterbrochen: …") + }) +}) diff --git a/frontend/src/lib/snapshots.ts b/frontend/src/lib/snapshots.ts new file mode 100644 index 0000000..79b0ffa --- /dev/null +++ b/frontend/src/lib/snapshots.ts @@ -0,0 +1,48 @@ +import type { HomelabLauf, HomelabSnapshots, SnapshotHerkunft } from "@/lib/typen" +import { flugplanZeit, vor } from "@/lib/zeit" + +// Die Seite Homelab → Snapshots (seit 25.09.2026): kleine Texte, damit die Ansicht nur noch zeichnet. Was erlaubt ist +// und die Rückfragen kommen vom Homelab-Teil (backend/services/homelab/snapshots.py). + +/** Die Läufe der Seite Snapshots — keine Updates: Sie gehören weder in den Update-Verlauf noch in „Zuletzt eingespielt“. */ +export const SNAPSHOT_LAEUFE = new Set(["snapshot-anlegen", "snapshot-loeschen", "snapshot-zurueck", "sicherung-loeschen"]) + +export const istSnapshotLauf = (l: Pick) => SNAPSHOT_LAEUFE.has(l.baustein) + +export const HERKUNFT: Record = { + update: { chip: "vor Update", text: "Rückweg vor einem Update" }, + knopf: { chip: "per Knopf", text: "Hier per Knopf angelegt" }, + proxmox: { chip: "von Hand", text: "Von Hand in Proxmox angelegt" }, +} + +/** „HEUTE 11:26“, „SA 08:00“, „20.09. 11:26“ — nach der Uhr des Homelab-Teils (jetzt in Unix-Sekunden). */ +export function zeitpunktText(zeit: number | null, jetzt: number): string { + if (zeit === null) return "Zeitpunkt unbekannt" + return flugplanZeit(new Date(zeit * 1000).toISOString(), new Date(jetzt * 1000)) +} + +/** „vor 2 h“, „vor 5 Tagen“ — leer, wo der Zeitpunkt fehlt. */ +export function alterText(zeit: number | null, jetzt: number): string { + return zeit === null ? "" : vor(zeit, jetzt * 1000) +} + +/** „361 MB“, „1,2 GB“ — wie die Rückfrage des Homelab-Teils; null, wo die Größe fehlt. Sicherungen sind oft kleiner + * als ein GB (die Übersicht importiert diese Datei, darum ohne lib/speicher). */ +export function groesseText(bytes: number | null): string | null { + if (bytes === null || bytes <= 0) return null + return bytes < 1e9 ? `${Math.round(bytes / 1e6)} MB` : `${(bytes / 1e9).toFixed(1).replace(".", ",")} GB` +} + +/** Das Ergebnis der letzten Aktion beim Gerät: ohne den Gerätenamen vorn, den die Meldung für Telegram braucht + * („Gitea: auf den Snapshot … zurückgesetzt“ → „Auf den Snapshot … zurückgesetzt“). */ +export function zuletztText(text: string, name: string): string { + const rest = text.startsWith(`${name}: `) ? text.slice(name.length + 2) : text + return rest.charAt(0).toUpperCase() + rest.slice(1) +} + +/** Oben rechts: „3 Snapshots · 1 Sicherung“. */ +export function summeText(s: HomelabSnapshots["summe"]): string { + const teile = [`${s.snapshots} ${s.snapshots === 1 ? "Snapshot" : "Snapshots"}`] + if (s.sicherungen > 0) teile.push(`${s.sicherungen} ${s.sicherungen === 1 ? "Sicherung" : "Sicherungen"}`) + return teile.join(" · ") +} diff --git a/frontend/src/lib/typen.ts b/frontend/src/lib/typen.ts index 2646e17..9725a03 100644 --- a/frontend/src/lib/typen.ts +++ b/frontend/src/lib/typen.ts @@ -295,7 +295,8 @@ export interface HomelabStand { ausfuehrer: { verbunden: boolean; zuletzt: number | null } } -/** Ein „Jetzt updaten“-Lauf im Homelab (GET /api/homelab/laeufe). */ +/** Ein Lauf im Homelab (GET /api/homelab/laeufe): „Jetzt updaten“ und seit 25.09.2026 die Aktionen der Seite + * Snapshots (Bausteine snapshot-anlegen, snapshot-loeschen, snapshot-zurueck, sicherung-loeschen). */ export interface HomelabLauf { id: string ziel: string @@ -304,7 +305,9 @@ export interface HomelabLauf { status: "laeuft" | "fertig" | "unterbrochen" start: number ende: number | null - ergebnis: "eingespielt" | "zurueckgerollt" | "fehler" | "neustart" | "aufgeraeumt" | null + ergebnis: + | "eingespielt" | "zurueckgerollt" | "fehler" | "neustart" | "aufgeraeumt" | "offen" + | "angelegt" | "geloescht" | "zurueckgesetzt" | null text: string | null schritte: string[] } @@ -444,7 +447,7 @@ export interface Sammellauf { export interface ProtokollEintrag { zeit: number - art: "auftrag" | "lauf" | "sammellauf" | "hinweis" | "meldung" | "pflege" + art: "auftrag" | "lauf" | "snapshot" | "sammellauf" | "hinweis" | "meldung" | "pflege" titel: string text: string | null stufe: "ok" | "info" | "warn" | "fehler" @@ -532,3 +535,63 @@ export interface HomelabSpeicher { sicherungen: SicherungsLage empfehlungen: SpeicherEmpfehlung[] } + +// --- Snapshots des Homelabs (GET /api/homelab/snapshots, seit 25.09.2026) --------------------------------------- + +/** Woher ein Snapshot stammt: Rückweg vor einem Update, per Knopf auf der Seite Snapshots, von Hand in Proxmox. */ +export type SnapshotHerkunft = "update" | "knopf" | "proxmox" + +export interface HomelabSnapshot { + name: string + /** Unix-Sekunden; null, wo Proxmox keinen Zeitpunkt nennt. */ + zeit: number | null + beschreibung: string | null + herkunft: SnapshotHerkunft + /** Vom Orchestrator (mc2-…): Nur solche lassen sich hier löschen oder zurücksetzen. */ + eigen: boolean + loeschen: ZielAktion | null + zuruecksetzen: ZielAktion | null +} + +/** Eine Sicherung des Orchestrators (vzdump-Archiv), wo vor Updates kein Snapshot geht (PBS). */ +export interface HomelabSicherungsArchiv { + datei: string + speicher: string + zeit: number | null + /** Bytes; null, solange der Ausführer sie nicht nennt. */ + groesse: number | null + loeschen: ZielAktion | null +} + +export interface SnapshotGeraet { + id: string + vmid: number + art: "container" | "vm" + name: string + /** „Container 104“ */ + wo: string + status: string | null + erlaubt: boolean + /** Knopf „Snapshot anlegen“; null, dann sagt grund, warum nicht. */ + anlegen: ZielAktion | null + grund: string | null + /** Was für das Gerät gerade läuft (auch ein Update), sonst null. */ + laeuft: string | null + /** Ergebnis der letzten Aktion dieser Seite, solange es frisch ist. */ + zuletzt: { ok: boolean; ende: number; text: string } | null + snapshots: HomelabSnapshot[] + sicherungen: HomelabSicherungsArchiv[] +} + +export interface HomelabSnapshots { + /** Uhr des Homelab-Teils (Unix-Sekunden) — danach rechnet die Seite das Alter. */ + jetzt: number + bericht: { empfangen: number; veraltet: boolean } | null + ausfuehrer: { verbunden: boolean; zuletzt: number | null; nur_lesen: boolean } + /** Warum gerade gar keine Aktion geht („Alle aktualisieren“, ein Update irgendwo, der Ausführer) — sonst null. */ + sperre: string | null + /** false: Der Ausführer ist älter als der 25.09.2026 und nennt nur Namen (Zeitpunkt aus dem Namen). */ + details: boolean + geraete: SnapshotGeraet[] + summe: { snapshots: number; eigene: number; sicherungen: number; sicherungen_groesse: number | null } +} diff --git a/frontend/src/views/Homelab.tsx b/frontend/src/views/Homelab.tsx index 6f9b773..224613f 100644 --- a/frontend/src/views/Homelab.tsx +++ b/frontend/src/views/Homelab.tsx @@ -13,12 +13,13 @@ import { useZielAktion, } from "@/lib/abfragen" import { lage, lampeFuer, offeneUpdates } from "@/lib/homelab" +import { istSnapshotLauf } from "@/lib/snapshots" import type { Hinweis, HomelabLauf, HomelabStand, PartnerStatus } from "@/lib/typen" import { flugplanZeit } from "@/lib/zeit" // Der Bereich Homelab: das Cockpit zeigt, wie es den Geräten geht (Lage, Hinweise, Netz, CPU, Speicher, -// Platte); die Updates-Seite zeigt je Gerät die Versionen, was ansteht und was gelaufen ist. Monitoring und -// Protokoll haben eigene Seiten. Aus der KI-Box steht hier nichts — die hat ihren eigenen Bereich. +// Platte); die Updates-Seite zeigt je Gerät die Versionen, was ansteht und was gelaufen ist. Snapshots, Monitoring +// und Protokoll haben eigene Seiten. Aus der KI-Box steht hier nichts — die hat ihren eigenen Bereich. /** Was der Homelab-Teil übernimmt (Bestandsaufnahme vom 24.09.2026). */ const GERAETE = ["Proxmox-Host", "AdGuard", "NPMplus", "NetBird", "PVE Scripts Local", "Gitea", "PBS", "Arcane mit Docker"] @@ -29,6 +30,7 @@ const ERGEBNIS: Record = { fehler: { art: "rot", text: "Fehler" }, neustart: { art: "cyan", text: "Neustart" }, aufgeraeumt: { art: "gruen", text: "aufgeräumt" }, + offen: { art: "cyan", text: "Probelauf" }, // Docker über Arcane, solange es nur probt } const zeitAus = (sekunden: number) => flugplanZeit(new Date(sekunden * 1000).toISOString()) @@ -97,14 +99,18 @@ function Hinweise({ hinweise }: { hinweise: Hinweis[] }) { ) } -/** Die letzten Läufe — gebaut wie der Verlauf der KI-Box: Zeit, Gerät, Ergebnis, der Satz darunter. */ +/** Die letzten Läufe — gebaut wie der Verlauf der KI-Box: Zeit, Gerät, Ergebnis, der Satz darunter. Die Aktionen der + * Seite Snapshots sind keine Updates und stehen dort. */ function Verlauf({ laeufe }: { laeufe: HomelabLauf[] }) { - const fertig = laeufe.filter((l) => l.status !== "laeuft").slice(0, 12) + const fertig = laeufe.filter((l) => l.status !== "laeuft" && !istSnapshotLauf(l)).slice(0, 12) if (fertig.length === 0) return

    Noch kein Update im Homelab eingespielt.

    return (
      {fertig.map((l) => { - const e = l.ergebnis ? ERGEBNIS[l.ergebnis] : { art: "grau" as ChipArt, text: "unterbrochen" } + // Ein Ergebnis ohne eigenen Eintrag riss die Seite vorher um (ERGEBNIS[…] war undefined). + const e = l.ergebnis + ? (ERGEBNIS[l.ergebnis] ?? { art: "grau" as ChipArt, text: l.ergebnis }) + : { art: "grau" as ChipArt, text: "unterbrochen" } return (
    1. @@ -188,18 +194,20 @@ function useHomelabBereich() { /** Homelab · Cockpit: die Lage auf einen Blick, Hinweise und wie es jedem Gerät geht. */ export function HomelabSeite() { const navigate = useNavigate() - const { ersatz, stand, laufend, hinweise, aktion } = useHomelabBereich() + const { ersatz, stand, laufend, laeufe, hinweise, aktion } = useHomelabBereich() const mess = useHomelabMesswerte("1h", !!stand) const speicher = useHomelabSpeicher(!!stand) if (ersatz || !stand) return ersatz const berichtZeit = stand.bericht ? zeitAus(stand.bericht.empfangen) : null - const l = lage(stand, hinweise, laufend.size, berichtZeit) + // „Update läuft“ nur für Updates — ein Snapshot anlegen oder löschen ist keins. + const imUpdate = new Set(laeufe.filter((x) => x.status === "laeuft" && !istSnapshotLauf(x)).map((x) => x.ziel)) + const l = lage(stand, hinweise, imUpdate.size, berichtZeit) return ( <> lampeFuer(z, laufend.has(z.id)))} + lampen={stand.ziele.map((z) => lampeFuer(z, imUpdate.has(z.id)))} onAnsehen={() => { if (l.ziel === "updates") void navigate({ to: "/homelab/updates" }) else if (l.ziel) document.getElementById(l.ziel)?.scrollIntoView({ behavior: "smooth", block: "start" }) @@ -231,6 +239,11 @@ export function HomelabSeite() { laeuft={laufend.get("pve") ?? null} gesperrt={aktion.isPending || laufend.has("pve") || !stand.ausfuehrer.verbunden} onAktion={(a) => aktion.mutate(a)} + snapshotsLink={ + + Zu den Snapshots + + } /> )} diff --git a/frontend/src/views/HomelabProtokoll.tsx b/frontend/src/views/HomelabProtokoll.tsx index 4ff68df..b120fdb 100644 --- a/frontend/src/views/HomelabProtokoll.tsx +++ b/frontend/src/views/HomelabProtokoll.tsx @@ -1,5 +1,5 @@ import { useState } from "react" -import { Bell, ChevronRight, Cog, RefreshCw, Search, TriangleAlert, type LucideIcon } from "lucide-react" +import { Bell, ChevronRight, Cog, History, RefreshCw, Search, TriangleAlert, type LucideIcon } from "lucide-react" import { cn } from "cn" import { Zustandsfeld } from "@/components/cockpit/Chip" import { Panel } from "@/components/cockpit/Panel" @@ -14,6 +14,7 @@ type Art = ProtokollEintrag["art"] const ARTEN: { id: Art | "alle"; name: string }[] = [ { id: "alle", name: "Alles" }, { id: "lauf", name: "Updates" }, + { id: "snapshot", name: "Snapshots" }, { id: "auftrag", name: "Ausführer" }, { id: "hinweis", name: "Hinweise" }, { id: "meldung", name: "Meldungen" }, @@ -22,6 +23,7 @@ const ARTEN: { id: Art | "alle"; name: string }[] = [ const SYMBOL: Record = { auftrag: Cog, lauf: RefreshCw, sammellauf: RefreshCw, hinweis: TriangleAlert, meldung: Bell, pflege: Search, + snapshot: History, } const STUFE: Record = { @@ -47,7 +49,9 @@ function tagUeberschrift(zeit: number): string { function Eintrag({ e, geraet }: { e: ProtokollEintrag; geraet: string | null }) { const [offen, setOffen] = useState(false) const s = STUFE[e.stufe] ?? STUFE.info - const Symbol = SYMBOL[e.art] ?? Cog + // Nicht „Symbol“ nennen: Im Entwicklungsmodus setzt der React Compiler seinen Zwischenspeicher oben in der Funktion + // mit Symbol.for(…) zurück — eine gleichnamige Konstante darunter ließ die Seite dort abstürzen. + const Zeichen = SYMBOL[e.art] ?? Cog return (
    2. {uhr.format(new Date(e.zeit * 1000))} @@ -56,7 +60,7 @@ function Eintrag({ e, geraet }: { e: ProtokollEintrag; geraet: string | null })
      - + {e.titel} {geraet && {geraet}} ({s.wort}) @@ -106,8 +110,8 @@ export function HomelabProtokollSeite() { return (

      - Was der Homelab-Teil getan hat: Aufträge an den Ausführer auf dem Proxmox-Host, Update-Läufe, Hinweise, - gesendete Meldungen und die nächtliche Paketsuche. + Was der Homelab-Teil getan hat: Aufträge an den Ausführer auf dem Proxmox-Host, Update-Läufe, Snapshots, + Hinweise, gesendete Meldungen und die nächtliche Paketsuche.

      {ARTEN.map((a) => ( diff --git a/frontend/src/views/HomelabSnapshots.tsx b/frontend/src/views/HomelabSnapshots.tsx new file mode 100644 index 0000000..b5cf23a --- /dev/null +++ b/frontend/src/views/HomelabSnapshots.tsx @@ -0,0 +1,66 @@ +import { Chip, Zustandsfeld } from "@/components/cockpit/Chip" +import { Panel } from "@/components/cockpit/Panel" +import { SnapshotListe } from "@/components/homelab/SnapshotListe" +import { useHomelabSnapshots, useInstanz, usePartner, useSnapshotAktion } from "@/lib/abfragen" +import { summeText, zeitpunktText } from "@/lib/snapshots" + +// Homelab · Snapshots (seit 25.09.2026, User-Wunsch): je Gerät seine Snapshots und die Sicherungen des Orchestrators, +// mit Knöpfen zum Anlegen, Löschen und Zurücksetzen. Was erlaubt ist und die Rückfragen kommen vom Homelab-Teil +// (backend/services/homelab/snapshots.py); die Aktionen laufen dort als Läufe wie die Updates. + +export function HomelabSnapshotsSeite() { + const instanz = useInstanz() + const partner = usePartner() + const aktiv = instanz.data?.rolle === "homelab" || !!(partner.data?.eingerichtet && partner.data.erreichbar) + const abfrage = useHomelabSnapshots(aktiv) + const aktion = useSnapshotAktion() + + if (instanz.isPending || partner.isPending) return + if (!aktiv) return + if (abfrage.isPending) return + if (!abfrage.data) { + return + } + + const d = abfrage.data + // Warum gerade gar keine Aktion geht („Alle aktualisieren“, ein Update, der Ausführer) — derselbe Satz wie beim Knopf. + const grund = d.sperre + return ( + {summeText(d.summe)} : undefined}> +

      + Ein Snapshot hält den Stand eines Geräts fest. Vor jedem Update legt der Orchestrator einen an (beim Proxmox + Backup Server eine Sicherung) und räumt nach einem grünen Update die älteren weg. Hier legst du selbst welche + an — die bleiben, bis du sie löschst —, setzt ein Gerät zurück oder löschst, was weg kann. Von Hand in Proxmox + angelegte stehen nur zur Ansicht da. +

      + {grund && ( +

      + {grund} +

      + )} + {d.bericht?.veraltet && ( +

      + Der letzte Bericht ist von {zeitpunktText(d.bericht.empfangen, d.jetzt)}; die Liste kann veraltet sein. +

      + )} + {!d.bericht ? ( +

      Der Ausführer hat noch keinen Bericht geschickt.

      + ) : ( + <> + {!d.details && ( +

      + Beschreibungen und die Größe der Sicherungen erscheinen, sobald der neue Ausführer auf dem Proxmox-Host + läuft; bis dahin kommt der Zeitpunkt aus dem Namen des Snapshots. +

      + )} + aktion.mutate(a)} /> +

      + Wie viel ein Snapshot im Speicherpool belegt, sagt Proxmox nicht: Er teilt sich die Daten mit dem Gerät und + wächst mit jeder Änderung seit seinem Zeitpunkt. Wie voll der Pool ist, steht im Cockpit unter „Speicher und + Sicherungen“. +

      + + )} +       + ) +} diff --git a/frontend/src/views/Uebersicht.tsx b/frontend/src/views/Uebersicht.tsx index 4e9fa01..efcdb6b 100644 --- a/frontend/src/views/Uebersicht.tsx +++ b/frontend/src/views/Uebersicht.tsx @@ -11,6 +11,7 @@ import { useUpdateVerlauf, } from "@/lib/abfragen" import { useBereichStand, type Verbindung } from "@/lib/navigation" +import { istSnapshotLauf } from "@/lib/snapshots" import { useLetzteMetrik } from "@/lib/strom" import type { Hinweis, Messpunkt } from "@/lib/typen" import { gesamtlage, type KurzZeile, kurzformen, type Lagestufe } from "@/lib/uebersicht" @@ -236,7 +237,8 @@ function Zuletzt({ homelabAktiv }: { homelabAktiv: boolean }) { ...(box.data?.laeufe ?? []).slice(0, 6).map((l) => ({ zeit: new Date(l.start).getTime(), bereich: "KI-Box", titel: l.anlass, chip: l.titel, art: ERGEBNIS[l.stufe] ?? "grau", })), - ...(lab.data?.laeufe ?? []).filter((l) => l.status !== "laeuft").slice(0, 6).map((l) => ({ + // Die Aktionen der Seite Snapshots sind keine Updates. + ...(lab.data?.laeufe ?? []).filter((l) => l.status !== "laeuft" && !istSnapshotLauf(l)).slice(0, 6).map((l) => ({ zeit: l.start * 1000, bereich: "Homelab", titel: l.name, chip: l.ergebnis ?? "unterbrochen", art: (l.ergebnis ? ERGEBNIS[l.ergebnis] : "grau") ?? "grau", })),