homelab: Wartezeit nach Skriptaenderung, PBS mit Sicherung statt Snapshot, woechentliches Suchen

- karenz.py: ct/<app>.sh juenger als MC_HOMELAB_KARENZ_H (Standard 48 h) -> Baustein "neu" ohne Knopf,
  updates.starten lehnt mit demselben Satz ab (Berliner Zeit). GitHub stumm -> nicht blockieren, die
  Rueckfrage sagt es.
- Ausfuehrer: neue Aktionen sichern, sicherung_zurueck, sicherung_loeschen. vzdump auf den ersten lokalen
  Speicher mit Inhalt backup (oder sicherung_speicher aus /etc/mc2-ausfuehrer.json), nie auf pbs; vorher
  Platz pruefen (frei > belegt x 1,2); Notiz mc2-sicherung, nur solche werden zurueckgespielt/geloescht;
  Rueckweg: stoppen, pct restore --force auf den bisherigen rootfs-Speicher, starten. Bericht mit
  host.sicherung, sicherung_moeglich/_grund, eigenen Sicherungen und nur_lesen. Unerwartete Fehler werden
  beantwortet statt verschluckt; vzdump/restore beim Zeitlimit erst SIGTERM.
- updates.py: Sicherung, wo kein Snapshot geht; bei Rot zurueckspielen, nach Gruen aeltere Sicherungen
  weg. Scheitert Snapshot oder Sicherung, beginnt das Update nicht (nicht dringend gemeldet).
- pflege.py: "suchen" fuer Gaeste mit Paketlisten aelter als 7 Tage, nachts 02-05 Uhr (sonst nachholen),
  einmal je Gast und Tag, nie neben einem Update oder offenen Auftrag; gelber Waechter-Hinweis, wenn es
  zweimal hintereinander scheitert. Eine Registrierungszeile in waechter.py.
- kanal.py: Auftragsliste unter flock, weil jetzt auch der Steward Auftraege anlegt.
- inventar.py: Rueckweg und Rueckfrage fuer die Sicherung; Gaeste mitten im Update-Lauf nicht in der
  Webpruefung des Waechters (sonst zweiter Alarm beim Zurueckspielen).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

backend/services/homelab/updates.py

@@ -4,12 +4,15 @@ Nur per Knopf, mit Erfolgsmeldung und Erreichbarkeits-Check; ist er rot, geht es
 und es wird gemeldet. Host-Updates gibt es mit Warnung, der Neustart ist ein eigener Knopf.
 
 Ablauf für einen Gast:
-  1. Snapshot (wo möglich; beim PBS verhindert der Bind-Mount ihn — dann ohne Rückweg, die Rückfrage sagt es)
-  2. Update: die App per Community-Script (`update`, still) oder die Pakete des Gasts
+  1. Rückweg anlegen: ein Snapshot; wo keiner geht (PBS: Bind-Mount), eine Sicherung (vzdump auf einen lokalen
+     Speicher des Hosts, nie auf den PBS); geht beides nicht, ohne Rückweg — die Rückfrage sagt es. Scheitert
+     dieser Schritt, beginnt das Update gar nicht.
+  2. Update: die App per Community-Script (`update`, still) oder die Pakete des Gasts. Ein frisch geändertes
+     Update-Skript wartet erst MC_HOMELAB_KARENZ_H Stunden (karenz.py).
   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 und Snapshot da → zurück auf den Snapshot → dringende Meldung.
-     Grün → ältere Snapshots des Orchestrators für diesen Gast weg → Meldung „eingespielt“.
+  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“.
 Jeder Lauf steht in <Datenordner>/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.
 """
@@ -27,13 +30,14 @@ from kern.einstellungen import einstellungen
 from kern.zeit import LOCAL_TZ
 
 from services import announce, update_verlauf
-from services.homelab import apps, arcane, inventar, kanal
+from services.homelab import apps, arcane, inventar, kanal, karenz
 
 log = logging.getLogger(__name__)
 
 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)
 BETREFF = "[Homelab-Update]"
 
 _lock = threading.RLock()     # _merken liest und schreibt unter derselben Sperre
@@ -65,6 +69,15 @@ def laeufe(anzahl: int = 20) -> list[dict]:
     return list(reversed(_laeufe()))[:anzahl]
 
 
+def laufende_ziele() -> set[str]:
+    """Ziele mit einem laufenden Update. Liest nur die Datei — geht also auch im Steward (Wächter, Pflege)."""
+    return {str(x.get("ziel")) for x in _laeufe() if x.get("status") == "laeuft"}
+
+
+def laeuft(ziel_id: str) -> bool:
+    return ziel_id in laufende_ziele()
+
+
 def unterbrochene_abschliessen() -> None:
     """Beim Start: Läufe, die noch „läuft“ heißen, gehörten zum vorigen Prozess."""
     for lauf in _laeufe():
@@ -123,39 +136,72 @@ def pruefen(vorher: dict, nachher: dict | None, baustein: str) -> list[str]:
     return fehler
 
 
+def _rueckweg_anlegen(lauf: dict, gast: dict) -> tuple[str, str] | None:
+    """Vor dem Update: ("snapshot", Name), wo keiner geht ("sicherung", Archiv), sonst None. Wirft RuntimeError,
+    wenn der Schritt scheitert (etwa zu wenig Platz) — dann beginnt das Update gar nicht."""
+    vmid = gast["vmid"]
+    if gast.get("snapshot_moeglich"):
+        a = _auftrag(lauf, "snapshot", {"vmid": vmid}, ZEITLIMIT_KURZ_S)
+        m = re.search(r"snapshot=(mc2-\d{8}-\d{6})", a.get("text") or "")
+        return ("snapshot", m.group(1)) if m else None
+    if gast.get("sicherung_moeglich"):
+        a = _auftrag(lauf, "sichern", {"vmid": vmid}, ZEITLIMIT_SICHERUNG_S)
+        m = re.search(r"^sicherung=(\S+)$", a.get("text") or "", re.MULTILINE)
+        if not m:
+            raise RuntimeError("sichern: Der Ausführer nannte keine Sicherung")
+        return ("sicherung", m.group(1))
+    return None
+
+
+def _zurueck(lauf: dict, vmid: int, rueckweg: tuple[str, str]) -> str:
+    """Den Rückweg gehen; Rückgabe: was geschah (für die Meldung). Wirft RuntimeError, wenn er scheitert."""
+    art, name = rueckweg
+    if art == "snapshot":
+        _auftrag(lauf, "zurueck", {"vmid": vmid, "snapshot": name}, ZEITLIMIT_KURZ_S)
+        return f"automatisch zurück auf den Snapshot {name}"
+    _auftrag(lauf, "sicherung_zurueck", {"vmid": vmid, "sicherung": name}, ZEITLIMIT_SICHERUNG_S)
+    return f"automatisch die Sicherung von vorher zurückgespielt ({name.rsplit('/', 1)[-1]})"
+
+
 def _gast_lauf(lauf: dict, gast: dict) -> None:
     vmid, baustein = gast["vmid"], lauf["baustein"]
-    snapshot = None
     try:
-        if gast.get("snapshot_moeglich"):
-            a = _auftrag(lauf, "snapshot", {"vmid": vmid}, ZEITLIMIT_KURZ_S)
-            m = re.search(r"snapshot=(mc2-\d{8}-\d{6})", a.get("text") or "")
-            snapshot = m.group(1) if m else None
+        rueckweg = _rueckweg_anlegen(lauf, gast)
+    except RuntimeError as exc:
+        _ende(lauf, "fehler", f"{lauf['name']}: Update nicht begonnen — {str(exc).rstrip('.')}. "
+                              "Am Gerät wurde nichts geändert.")
+        return
+    try:
         _auftrag(lauf, "update" if baustein == "app" else "os_update", {"vmid": vmid}, ZEITLIMIT_UPDATE_S)
         time.sleep(WARTEN_NACH_UPDATE_S)
         fehler = pruefen(gast, _frischer_gast(lauf, vmid), baustein)
     except RuntimeError as exc:
         fehler = [str(exc)]
     if not fehler:
-        _aufraeumen(lauf, vmid, behalten=snapshot)
+        _aufraeumen(lauf, vmid, rueckweg)
         _ende(lauf, "eingespielt", f"{lauf['name']}: eingespielt, Prüfung grün.")
         return
-    if snapshot:
+    if rueckweg:
         try:
-            _auftrag(lauf, "zurueck", {"vmid": vmid, "snapshot": snapshot}, ZEITLIMIT_KURZ_S)
+            wie = _zurueck(lauf, vmid, rueckweg)
             _ende(lauf, "zurueckgerollt",
-                  f"{lauf['name']}: Update gescheitert ({' '.join(fehler)}) — automatisch zurück auf den Snapshot "
-                  f"{snapshot}. Läuft wieder wie vorher.", dringend=True)
+                  f"{lauf['name']}: 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}")
+            if rueckweg[0] == "sicherung":
+                fehler.append(f"Die Sicherung {rueckweg[1]} liegt weiter auf dem Proxmox-Host.")
     _ende(lauf, "fehler", f"{lauf['name']}: Update gescheitert — {' '.join(fehler)}"
-                          + ("" if snapshot else " Es gab keinen Snapshot, also keinen automatischen Rückweg."),
+                          + ("" if rueckweg else " Es gab weder Snapshot noch Sicherung, also keinen automatischen "
+                                                 "Rückweg."),
           dringend=True)
 
 
-def _aufraeumen(lauf: dict, vmid: int, behalten: str | None) -> None:
-    """Ältere Snapshots des Orchestrators für diesen Gast löschen; den neuesten behalten."""
+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."""
+    art, behalten = rueckweg or (None, None)
     gast = inventar.gast(lauf["ziel"]) or {}
     for name in gast.get("snapshots") or []:
         if name.startswith("mc2-") and name != behalten:
@@ -163,6 +209,14 @@ def _aufraeumen(lauf: dict, vmid: int, behalten: str | None) -> None:
                 _auftrag(lauf, "snapshot_loeschen", {"vmid": vmid, "snapshot": name}, ZEITLIMIT_KURZ_S)
             except RuntimeError:
                 lauf["schritte"].append(f"Alter Snapshot {name} blieb stehen.")
+    if art != "sicherung":
+        return
+    for volid in gast.get("sicherungen") or []:
+        if volid != behalten:
+            try:
+                _auftrag(lauf, "sicherung_loeschen", {"vmid": vmid, "sicherung": volid}, ZEITLIMIT_KURZ_S)
+            except RuntimeError:
+                lauf["schritte"].append(f"Alte Sicherung {volid} blieb stehen.")
 
 
 def _docker_lauf(lauf: dict, basis: str) -> None:
@@ -224,7 +278,7 @@ def starten(ziel_id: str, baustein: str) -> dict:
     """Knopf „Jetzt updaten“. Rückgabe {"ok": True, "lauf": id} oder {"ok": False, "detail": …}."""
     if baustein not in ("app", "os", "pakete", "neustart", "docker"):
         return {"ok": False, "detail": "Unbekannter Baustein."}
-    if any(x.get("ziel") == ziel_id and x.get("status") == "laeuft" for x in _laeufe()):
+    if laeuft(ziel_id):
         return {"ok": False, "detail": "Für dieses Gerät läuft schon ein Update."}
     if ziel_id == "pve":
         name, gast = "Proxmox-Host", None
@@ -247,6 +301,8 @@ def starten(ziel_id: str, baustein: str) -> dict:
         if baustein == "app" and (not app or app.weg != "skript"):
             return {"ok": False, "detail": f"{name} aktualisiert sich nicht über das Community-Script "
                                           "(eigene Oberfläche oder Pakete)."}
+        if baustein == "app" and (sperre := karenz.pruefen(app.kennung)["gesperrt"]):
+            return {"ok": False, "detail": sperre}
     lauf = _neuer_lauf(ziel_id, baustein, name)
     ziel = _host_lauf if gast is None else (lambda lf: _gast_lauf(lf, gast))
     threading.Thread(target=ziel, args=(lauf,), name=f"homelab-{ziel_id}", daemon=True).start()