From 67ed0458a956187221cc9dff8ede8ca3f8ed6ef8 Mon Sep 17 00:00:00 2001 From: Hitonabi Date: Fri, 25 Sep 2026 10:29:07 +0200 Subject: [PATCH] =?UTF-8?q?homelab:=20Arcane-Docker=20ehrlich=20zum=20R?= =?UTF-8?q?=C3=BCckweg=20=E2=80=93=20Snapshot=20der=20VM=20nur=20mit=20Eti?= =?UTF-8?q?kett=20watcher?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Die Update-Liste zeigte bei Arcane „Snapshot vorher, bei Rot zurück“, obwohl das Docker-Update keinen Snapshot anlegte (und der Ausführer VM 106 ohne Etikett gar nicht anfassen darf). Jetzt: - Gäste ohne Freigabe haben Rückweg „keiner“, Rückfrage und Plan sagen es. - Echte Docker-Updates legen vorher einen Snapshot der VM an, wenn sie freigegeben ist, prüfen danach (Fehler-Container, Arcane antwortet binnen 3 min) und gehen bei Rot zurück – wie bei den Containern. Co-Authored-By: Claude Opus 5.5 --- backend/services/homelab/inventar.py | 20 ++++-- backend/services/homelab/sammellauf.py | 2 +- backend/services/homelab/updates.py | 67 +++++++++++++++++---- backend/tests/test_homelab.py | 37 ++++++++++++ backend/tests/test_homelab_einstellungen.py | 8 +-- docs/ARCHITEKTUR.md | 5 +- docs/BEDIENUNG.md | 3 +- 7 files changed, 117 insertions(+), 25 deletions(-) diff --git a/backend/services/homelab/inventar.py b/backend/services/homelab/inventar.py index f3faf5f..4163fa1 100644 --- a/backend/services/homelab/inventar.py +++ b/backend/services/homelab/inventar.py @@ -9,7 +9,8 @@ Wie ehrlich der Stand ist, steht dabei: Sind die Paketlisten im Gast älter als „unbekannt“ (mit Knopf zum Suchen) statt „aktuell“; ist der Bericht älter als eine halbe Stunde, sagt die Übersicht, dass der Ausführer schweigt. Ist das Update-Skript einer App frisch geändert, bleibt sie „neu“, aber ohne Knopf (karenz.py). Rückweg und Rückfrage sagen, was vor dem Update geschieht: Snapshot, -wo keiner geht eine Sicherung, sonst keiner. +wo keiner geht eine Sicherung, sonst keiner. Ohne Freigabe (Etikett) legt der Ausführer weder das eine noch +das andere an — das betrifft Arcane, dessen Docker-Updates auch ohne Etikett über Arcane selbst laufen. """ import re @@ -28,6 +29,7 @@ BERICHT_ALT_S = 30 * 60 LISTEN_ALT_S = 14 * 24 * 3600 EIGENES_ETIKETT = "mc2" ERREICHBAR_CACHE_S = 60 +OHNE_FREIGABE = "Das Etikett „watcher“ fehlt, der Ausführer darf hier keinen Snapshot anlegen" _erreichbar_cache: dict[str, tuple[float, bool]] = {} _erreichbar_lock = threading.Lock() @@ -74,6 +76,8 @@ def _datum(ts: float | None) -> str: def _rueckweg(gast: dict) -> str: """Die Zeile „Rückweg“ der Karte: was vor jedem Update geschieht.""" + if not gast.get("erlaubt"): + return f"Kein automatischer Rückweg: {OHNE_FREIGABE}." if gast.get("snapshot_moeglich"): return "Snapshot vor jedem Update" grund = gast.get("snapshot_grund") or "kein Snapshot möglich" @@ -86,6 +90,8 @@ def _rueckweg(gast: dict) -> str: def _rueckweg_art(gast: dict) -> str: """Dasselbe in einem Wort — die Oberfläche fasst den Rückweg in der Update-Liste kurz.""" + if not gast.get("erlaubt"): + return "keiner" if gast.get("snapshot_moeglich"): return "snapshot" return "sicherung" if gast.get("sicherung_moeglich") else "keiner" @@ -93,6 +99,8 @@ def _rueckweg_art(gast: dict) -> str: def _rueckweg_frage(gast: dict) -> str: """Der Satz zum Rückweg in der Rückfrage vor „Jetzt updaten“.""" + if not gast.get("erlaubt"): + return f"{OHNE_FREIGABE} — scheitert das Update, gibt es keinen automatischen Rückweg." if gast.get("snapshot_moeglich"): return "Vorher wird ein Snapshot angelegt; ist die Prüfung danach rot, geht es von selbst zurück." if gast.get("sicherung_moeglich"): @@ -166,7 +174,7 @@ def _os_baustein(gast: dict, zid: str, jetzt: float) -> BausteinStand: return stand -def _arcane_bausteine(basis: str | None, zid: str) -> list[BausteinStand]: +def _arcane_bausteine(basis: str | None, zid: str, gast: dict) -> list[BausteinStand]: """Arcane selbst (öffentliche Version) und die Docker-Images (mit API-Schlüssel).""" app = arcane.app_version(basis) if basis else None selbst = BausteinStand(id="arcane", name="Arcane", zustand="unbekannt", @@ -195,7 +203,8 @@ def _arcane_bausteine(basis: str | None, zid: str) -> list[BausteinStand]: docker.aktion = Aktion( "POST", f"/api/homelab/ziele/{zid}/docker", ("Arcane prüft im Probelauf, welche Container es aktualisieren würde — geändert wird noch nichts." - if probe else "Arcane aktualisiert jetzt die Container mit neuen Images; Daten-Volumes bleiben."), + if probe else "Arcane aktualisiert jetzt die Container mit neuen Images; Daten-Volumes bleiben. " + + _rueckweg_frage(gast)), label="Probelauf" if probe else "Jetzt updaten") else: docker.zustand = "aktuell" @@ -216,8 +225,9 @@ def _gast_ziel(gast: dict, jetzt: float) -> ZielStand: grund=f"Der Gast ist {gast.get('status') or 'unbekannt'}.")) return ziel if app and app.kennung == "arcane": - # Arcane läuft über seine eigene Schnittstelle, nicht über den Ausführer: kein Etikett nötig. - ziel.bausteine += _arcane_bausteine(url.rstrip("/") if url else None, zid) + # Arcane läuft über seine eigene Schnittstelle, nicht über den Ausführer: kein Etikett nötig — nur für den + # Snapshot vorher (Rückweg), den legt der Ausführer an. + ziel.bausteine += _arcane_bausteine(url.rstrip("/") if url else None, zid, gast) return ziel if not gast.get("erlaubt"): ziel.bausteine.append(BausteinStand( diff --git a/backend/services/homelab/sammellauf.py b/backend/services/homelab/sammellauf.py index 24f7c9e..aa18e5f 100644 --- a/backend/services/homelab/sammellauf.py +++ b/backend/services/homelab/sammellauf.py @@ -146,7 +146,7 @@ def plan() -> dict: if not arcane.echt(): docker_probe = True # ein Probelauf ist kein Update else: - gaeste.append({**schritt, "rueckweg_art": "keiner"}) # Arcane legt keinen Snapshot an + gaeste.append(schritt) # Snapshot der VM nur mit Etikett watcher — rueckweg_art sagt es elif b["id"] in GAST_BAUSTEINE: gaeste.append(schritt) gaeste.sort(key=_rang) # sort ist stabil: je Gast bleibt die Reihenfolge seiner Bausteine diff --git a/backend/services/homelab/updates.py b/backend/services/homelab/updates.py index a465e52..ee607b7 100644 --- a/backend/services/homelab/updates.py +++ b/backend/services/homelab/updates.py @@ -13,6 +13,9 @@ Ablauf für einen Gast: 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“. +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), sonst +ohne; Rückfrage und Update-Liste sagen es. Jeder Lauf steht in /homelab-laeufe.json und im strukturierten Update-Verlauf. Pro Ziel läuft höchstens ein Lauf; startet dieser Teil neu, gilt ein offener Lauf als unterbrochen. @@ -42,6 +45,7 @@ WARTEN_NACH_UPDATE_S = 20 ZEITLIMIT_UPDATE_S = 45 * 60 ZEITLIMIT_KURZ_S = 15 * 60 ZEITLIMIT_SICHERUNG_S = 40 * 60 # Sicherung und Zurückspielen (der Ausführer gibt nach 30 min auf) +ARCANE_FRIST_S = 180 # so lange darf Arcane nach einem Docker-Update brauchen, bis es wieder antwortet BETREFF = "[Homelab-Update]" BETREFF_ALARM = "[Alarm] Homelab-Update" SAMMELLAUF_SPERRE = "Es läuft gerade ‚Alle aktualisieren‘." @@ -243,28 +247,65 @@ def _aufraeumen(lauf: dict, vmid: int, rueckweg: tuple[str, str] | None) -> None lauf["schritte"].append(f"Alte Sicherung {volid} blieb stehen.") -def _docker_lauf(lauf: dict, basis: str) -> None: - """Docker über Arcanes Updater — zuerst nur als Probelauf (User-Entscheid 24.09.2026).""" +def _antwortet_wieder(url: str) -> bool: + """Nach dem Update starten Container neu: Arcane darf sich ARCANE_FRIST_S lang sammeln, bevor es rot heißt.""" + ende = time.monotonic() + ARCANE_FRIST_S + while not inventar.erreichbar_frisch(url): + if time.monotonic() >= ende: + return False + time.sleep(10) + return True + + +def _docker_lauf(lauf: dict, basis: str, gast: dict) -> None: + """Docker über Arcanes Updater — ein Probelauf, bis der Schalter in den Einstellungen auf „echt“ steht + (User-Entscheid 24.09.2026). Echt wie bei den Containern: vorher ein Snapshot der VM, wenn der Ausführer sie + anfassen darf (Etikett watcher); ist die Prüfung danach rot, geht es darauf zurück.""" probe = not arcane.echt() + rueckweg = None + if not probe and gast.get("erlaubt"): + try: + rueckweg = _rueckweg_anlegen(lauf, gast) + except RuntimeError as exc: + _ende(lauf, "fehler", f"Arcane: Update nicht begonnen — {str(exc).rstrip('.')}. " + "Am Gerät wurde nichts geändert.") + return try: ergebnisse = arcane.updater(basis, probelauf=probe) except Exception as exc: - _ende(lauf, "fehler", f"Arcane: Updater gescheitert — {exc}", dringend=not probe) - return + if probe: + _ende(lauf, "fehler", f"Arcane: Probelauf gescheitert — {exc}") + return + ergebnisse, fehler = {}, [f"Der Updater brach ab ({exc})."] + else: + fehler = [] gesamt = {k: sum(int((e or {}).get(k) or 0) for e in ergebnisse.values()) for k in ("checked", "updated", "failed")} namen = [str(i.get("resourceName")) for e in ergebnisse.values() for i in (e or {}).get("items") or [] if isinstance(i, dict) and i.get("updateAvailable")] if probe: _ende(lauf, "offen", f"Arcane-Probelauf: {len(namen)} von {gesamt['checked']} Containern würden aktualisiert" + (f" ({', '.join(namen[:8])})" if namen else "") + ". Geändert wurde nichts.") - elif gesamt["failed"]: - _ende(lauf, "fehler", f"Arcane: {gesamt['failed']} Container ließen sich nicht aktualisieren, " - f"{gesamt['updated']} schon.", dringend=True) - else: - ok = inventar.erreichbar_frisch(basis + "/") - _ende(lauf, "eingespielt" if ok else "fehler", - f"Arcane: {gesamt['updated']} Container aktualisiert" + ("." if ok else ", aber Arcane antwortet danach nicht."), - dringend=not ok) + return + if gesamt["failed"]: + fehler.append(f"{gesamt['failed']} Container ließen sich nicht aktualisieren, {gesamt['updated']} schon.") + if not _antwortet_wieder(basis + "/"): + fehler.append("Arcane antwortet danach nicht.") + if not fehler: + if rueckweg: + _aufraeumen(lauf, gast["vmid"], rueckweg) + _ende(lauf, "eingespielt", f"Arcane: {gesamt['updated']} Container aktualisiert, Prüfung grün.") + return + if rueckweg: + try: + wie = _zurueck(lauf, gast["vmid"], rueckweg) + _ende(lauf, "zurueckgerollt", f"Arcane: Update gescheitert ({' '.join(fehler)}) — {wie}. " + "Läuft wieder wie vorher.", dringend=True) + return + except RuntimeError as exc: + fehler.append(f"Auch der Rückweg scheiterte: {exc}") + _ende(lauf, "fehler", f"Arcane: Update gescheitert — {' '.join(fehler)}" + + ("" if rueckweg else " Es gab keinen Snapshot, also keinen automatischen Rückweg."), + dringend=True) def _host_lauf(lauf: dict) -> None: @@ -332,7 +373,7 @@ def starten(ziel_id: str, baustein: str, sammellauf: dict | None = None) -> dict if not (app and app.kennung == "arcane" and basis and arcane.schluessel()): return {"ok": False, "detail": "Docker-Updates gehen nur über Arcane mit API-Schlüssel."} lauf = _neuer_lauf(ziel_id, baustein, app.name, sammellauf) - threading.Thread(target=_docker_lauf, args=(lauf, basis), name=f"homelab-{ziel_id}", + threading.Thread(target=_docker_lauf, args=(lauf, basis, gast), name=f"homelab-{ziel_id}", daemon=True).start() return {"ok": True, "lauf": lauf["id"]} if not gast.get("erlaubt"): diff --git a/backend/tests/test_homelab.py b/backend/tests/test_homelab.py index 4ae360f..747a55a 100644 --- a/backend/tests/test_homelab.py +++ b/backend/tests/test_homelab.py @@ -284,6 +284,43 @@ def test_docker_ueber_arcane_erst_als_probelauf(ausfuehrer, monkeypatch): assert updates.starten("vm-106", "docker")["ok"] is False +def test_docker_echt_mit_snapshot_nur_mit_etikett(ausfuehrer, monkeypatch): + starten, protokoll, meldungen, _ = ausfuehrer + monkeypatch.setenv("MC_ARCANE_KEY", "schluessel") + monkeypatch.setenv("MC_ARCANE_ECHT", "1") + monkeypatch.setattr(updates, "ARCANE_FRIST_S", 0) + monkeypatch.setattr(inventar.arcane, "images_mit_update", lambda url: [ + {"name": "nginx:alpine", "aktuell": None, "neu": None, "umgebung": 0, "benutzt": ["web"]}]) + ergebnis = {"local": {"checked": 7, "updated": 1, "failed": 0, "items": []}} + monkeypatch.setattr(updates.arcane, "updater", lambda url, probelauf: ergebnis) + starten("1.27.3") + + # Ohne Etikett (wie VM 106 heute): kein Snapshot — Update-Liste und Rückfrage sagen es, statt einen zu versprechen. + arcane_ziel = _ziele(None)["vm-106"] + docker = {b["id"]: b for b in arcane_ziel["bausteine"]}["docker"] + assert arcane_ziel["rueckweg_art"] == "keiner" and "Etikett „watcher“ fehlt" in docker["aktion"]["frage"] + lauf = _auf_ende(updates.starten("vm-106", "docker")["lauf"]) + assert (lauf["ergebnis"], protokoll) == ("eingespielt", []) + + # Mit Etikett: vorher ein Snapshot der VM; ist die Prüfung rot, geht es darauf zurück. + bericht = json.loads(json.dumps(BERICHT)) + next(g for g in bericht["gaeste"] if g["vmid"] == 106)["erlaubt"] = True + kanal.bericht_speichern(bericht) + arcane_ziel = next(z for z in inventar.ziele()["ziele"] if z["id"] == "vm-106") + docker = {b["id"]: b for b in arcane_ziel["bausteine"]}["docker"] + assert arcane_ziel["rueckweg_art"] == "snapshot" and "Vorher wird ein Snapshot angelegt" in docker["aktion"]["frage"] + ergebnis["local"]["failed"] = 1 + lauf = _auf_ende(updates.starten("vm-106", "docker")["lauf"]) + assert (lauf["ergebnis"], protokoll) == ("zurueckgerollt", ["snapshot", "zurueck"]) + text, dringend = meldungen[-1] + assert dringend and "zurück auf den Snapshot mc2-20260924-190000" in text and "1 Container" in text + + ergebnis["local"]["failed"] = 0 + lauf = _auf_ende(updates.starten("vm-106", "docker")["lauf"]) + assert lauf["ergebnis"] == "eingespielt" and protokoll[2:] == ["snapshot"] + assert meldungen[-1] == ("Arcane: 1 Container aktualisiert, Prüfung grün.", False) + + def test_ausfuehrer_nur_lesen(monkeypatch): a = _ausfuehrer_modul() monkeypatch.setattr(a, "NUR_LESEN", True) diff --git a/backend/tests/test_homelab_einstellungen.py b/backend/tests/test_homelab_einstellungen.py index 66e67fb..3ab268d 100644 --- a/backend/tests/test_homelab_einstellungen.py +++ b/backend/tests/test_homelab_einstellungen.py @@ -123,7 +123,7 @@ def test_richtiger_schluessel_wird_gespeichert_und_gilt_sofort(daten, arcane_nac assert datei.stat().st_mode & 0o077 == 0 assert _client().get("/api/homelab/einstellungen").json()["arcane"]["schluessel"] == "hinterlegt" # Ohne Neustart: Die Übersicht fragt Arcane mit dem neuen Schlüssel und sieht die Images. - _, docker = inventar._arcane_bausteine(url, "vm-106") + _, docker = inventar._arcane_bausteine(url, "vm-106", {}) assert (docker.zustand, docker.kurz, docker.aktion.label) == ("neu", "1 Images", "Probelauf") assert RICHTIG not in caplog.text @@ -180,7 +180,7 @@ def test_loeschen(daten): assert not (daten / "arcane.key").exists() and arcane.schluessel_quelle() == "fehlt" assert _client().delete("/api/homelab/einstellungen/arcane-schluessel").json()["text"] == ( "Es war kein Arcane-Schlüssel hinterlegt.") - docker = inventar._arcane_bausteine("http://127.0.0.1:9", "vm-106")[1] + docker = inventar._arcane_bausteine("http://127.0.0.1:9", "vm-106", {})[1] assert docker.zustand == "unbekannt" and docker.grund.startswith("Es fehlt ein Arcane-API-Schlüssel") @@ -218,9 +218,9 @@ def test_echt_schalter(daten, monkeypatch): def test_echt_schalter_macht_aus_dem_probelauf_ein_update(daten, arcane_nachbau): url, _ = arcane_nachbau assert einstellungen.arcane_schluessel_setzen(RICHTIG)["ok"] - assert inventar._arcane_bausteine(url, "vm-106")[1].aktion.label == "Probelauf" + assert inventar._arcane_bausteine(url, "vm-106", {})[1].aktion.label == "Probelauf" assert einstellungen.arcane_echt_setzen(True)["ok"] - assert inventar._arcane_bausteine(url, "vm-106")[1].aktion.label == "Jetzt updaten" + assert inventar._arcane_bausteine(url, "vm-106", {})[1].aktion.label == "Jetzt updaten" # --- Herkunftsprüfung (Middleware der App, Rolle homelab) --------------------------------------------------------- diff --git a/docs/ARCHITEKTUR.md b/docs/ARCHITEKTUR.md index a8f8222..d174d05 100644 --- a/docs/ARCHITEKTUR.md +++ b/docs/ARCHITEKTUR.md @@ -326,7 +326,10 @@ flowchart LR (`arcane.key`); beides wird bei jedem Zugriff gelesen, ein neuer Schlüssel gilt ohne Neustart. Docker-Updates laufen zuerst nur als Probelauf (`dryRun`); echt, wenn der Schalter in den Einstellungen an ist. Setzt die Umgebung `MC_ARCANE_ECHT`, gewinnt sie (`1` = echt). Die Arcane-VM braucht dafür kein Etikett, weil der Ausführer nicht - beteiligt ist. + beteiligt ist — nur für den Rückweg: Mit Etikett `watcher` legt der Ausführer vor einem echten Docker-Update einen + Snapshot der VM an (`qm snapshot`), und ist die Prüfung danach rot (ein Container scheiterte, oder Arcane antwortet + nach 3 Minuten noch nicht), geht es darauf zurück. Ohne Etikett gibt es keinen Rückweg; Update-Liste, Rückfrage und + der Plan von „Alle aktualisieren“ sagen das (`rueckweg_art` = `keiner` für jeden Gast ohne Freigabe). - **Wächter** in der Rolle `homelab`: Platte, Partner (die KI-Box), Ausführer (kein Bericht seit 30 min = rot), jede Weboberfläche der freigegebenen Gäste (außer mitten in ihrem Update-Lauf; das Ergebnis meldet der Lauf), die Platten der laufenden Container (ab 80 % gelb, ab 90 % rot — ext4 hält 5 % für root zurück; der Ausführer schickt `platte` mit), das diff --git a/docs/BEDIENUNG.md b/docs/BEDIENUNG.md index 7c4ad6e..2f8b0ca 100644 --- a/docs/BEDIENUNG.md +++ b/docs/BEDIENUNG.md @@ -155,7 +155,8 @@ Eine eigene Seite mit vier Karten: KI-Box, Homelab, Meldungen, Software-Stand. und speichern“ fragt Arcane zuerst, ob der Schlüssel gilt; erst dann wird er gespeichert — im Homelab-Teil, nicht auf der KI-Box — und nie wieder angezeigt. Danach sieht der Orchestrator, welche Docker-Images neuer sind. - **Docker-Updates (Homelab):** ab Werk nur ein Probelauf (Arcane zeigt, was es täte). „Echt schalten“ fragt nach und - lässt sich jederzeit zurückschalten. + lässt sich jederzeit zurückschalten. Einen Snapshot der Arcane-VM vorher (und den Weg zurück bei Rot) gibt es nur, + wenn die VM in Proxmox das Etikett `watcher` trägt; sonst steht in der Update-Liste „Kein automatischer Rückweg“. - **Ausführer und Updates (Homelab):** ob der Ausführer auf dem Proxmox-Host verbunden ist, in welchem Modus, wohin Sicherungen gehen und wie lange nach einer Änderung am Update-Skript einer App gewartet wird. - **Hugging-Face-Zugang:** nötig für gesperrte Modelle und für schnellere Downloads. Eintragen, speichern, bei Bedarf