HitonabiandClaude Opus 5.5
77ecb35a6d
Neuer Baustein „probe“ (POST /api/homelab/ziele/{id}/rueckweg-probe): legt den
Rückweg an wie vor einem Update, wertet die Prüfung absichtlich als rot, geht
zurück und prüft danach, ob das Gerät läuft und antwortet. Kein Update dabei;
Meldung grün bzw. dringend rot. Die Probe steht im Protokoll, nicht im
Update-Verlauf und nicht unter „Zuletzt eingespielt“. Der Snapshot bleibt
liegen (wie nach einem echten Rückweg).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
460 lines
24 KiB
Python
460 lines
24 KiB
Python
"""„Jetzt updaten“ im Homelab (Phase 4, User-Entscheide 24.09.2026).
|
||
|
||
Nur per Knopf, mit Erfolgsmeldung und Erreichbarkeits-Check; ist er rot, geht es automatisch zurück
|
||
und es wird gemeldet. Host-Updates gibt es mit Warnung, der Neustart ist ein eigener Knopf.
|
||
|
||
Ablauf für einen Gast:
|
||
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 → 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 (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.
|
||
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.
|
||
|
||
„Rückweg testen“ (Baustein „probe“, seit 25.09.2026): Snapshot bzw. Sicherung anlegen, die Prüfung absichtlich als
|
||
rot werten, zurückgehen und nachprüfen, ob das Gerät danach läuft und antwortet. Ein Update gibt es dabei nicht; so
|
||
lässt sich der Weg zurück jederzeit echt beweisen, ohne auf ein gescheitertes Update zu warten.
|
||
|
||
„Alle aktualisieren“ (sammellauf.py, seit 24.09.2026) stößt dieselben Läufe nacheinander an. Solange es läuft,
|
||
lehnt der einzelne Knopf ab (SAMMELLAUF_SPERRE), und die Erfolgsmeldung eines Schritts entfällt — die Sammelmeldung
|
||
am Ende sagt es; Fehler werden weiter sofort gemeldet.
|
||
"""
|
||
|
||
import json
|
||
import logging
|
||
import re
|
||
import threading
|
||
import time
|
||
import uuid
|
||
from datetime import datetime
|
||
from pathlib import Path
|
||
|
||
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, 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)
|
||
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‘."
|
||
|
||
_lock = threading.RLock() # _merken liest und schreibt unter derselben Sperre
|
||
# Prüfen und Anlegen eines Laufs am Stück — auch „Alle aktualisieren“ legt sich unter ihr an. Sonst könnte ein
|
||
# einzelner Knopf genau zwischen Prüfung und Anlegen des Sammellaufs durchrutschen.
|
||
START_SPERRE = threading.Lock()
|
||
|
||
|
||
def _pfad() -> Path:
|
||
return einstellungen().daten_dir / "homelab-laeufe.json"
|
||
|
||
|
||
def _laeufe() -> list[dict]:
|
||
with _lock:
|
||
try:
|
||
daten = json.loads(_pfad().read_text(encoding="utf-8"))
|
||
except (OSError, ValueError):
|
||
return []
|
||
return daten if isinstance(daten, list) else []
|
||
|
||
|
||
def _merken(lauf: dict) -> None:
|
||
with _lock:
|
||
laeufe = [x for x in _laeufe() if x["id"] != lauf["id"]] + [lauf]
|
||
_pfad().parent.mkdir(parents=True, exist_ok=True)
|
||
tmp = _pfad().with_suffix(".tmp")
|
||
tmp.write_text(json.dumps(laeufe[-100:], ensure_ascii=False), encoding="utf-8")
|
||
tmp.replace(_pfad())
|
||
|
||
|
||
def laeufe(anzahl: int = 20) -> list[dict]:
|
||
return list(reversed(_laeufe()))[:anzahl]
|
||
|
||
|
||
def lauf_lesen(lauf_id: str) -> dict | None:
|
||
return next((x for x in _laeufe() if x.get("id") == lauf_id), None)
|
||
|
||
|
||
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 — ebenso ein laufendes
|
||
„Alle aktualisieren“ (danach, damit es den unterbrochenen Lauf schon als solchen sieht)."""
|
||
for lauf in _laeufe():
|
||
if lauf.get("status") == "laeuft":
|
||
lauf.update(status="unterbrochen", ende=time.time())
|
||
lauf["schritte"].append("Der Homelab-Teil wurde während des Laufs neu gestartet.")
|
||
_merken(lauf)
|
||
from services.homelab import sammellauf # sammellauf importiert dieses Modul
|
||
sammellauf.unterbrochene_abschliessen()
|
||
|
||
|
||
def _sammellauf_laeuft() -> bool:
|
||
from services.homelab import sammellauf
|
||
return sammellauf.laeuft()
|
||
|
||
|
||
def _melden(text: str, dringend: bool = False) -> None:
|
||
try:
|
||
announce.notify_telegram(BETREFF_ALARM if dringend else BETREFF, text)
|
||
except Exception:
|
||
log.warning("homelab: Meldung ging nicht raus", exc_info=True)
|
||
|
||
|
||
def _auftrag(lauf: dict, aktion: str, parameter: dict, zeitlimit_s: float) -> dict:
|
||
"""Auftrag an den Ausführer und auf das Ergebnis warten. Wirft RuntimeError bei Fehler/Zeitablauf."""
|
||
aid = kanal.anlegen(aktion, parameter)
|
||
lauf["schritte"].append(f"{aktion} …")
|
||
_merken(lauf)
|
||
a = kanal.warten(aid, zeitlimit_s)
|
||
if a is None:
|
||
raise RuntimeError(f"{aktion}: keine Antwort des Ausführers in {int(zeitlimit_s // 60)} Minuten")
|
||
if a["status"] != "fertig":
|
||
raise RuntimeError(f"{aktion} gescheitert: {str(a.get('text') or '')[-300:]}")
|
||
lauf["schritte"][-1] = f"{aktion}: ok"
|
||
return a
|
||
|
||
|
||
def _frischer_gast(lauf: dict, vmid: int) -> dict | None:
|
||
try:
|
||
a = _auftrag(lauf, "bericht", {}, 5 * 60)
|
||
bericht = json.loads(a.get("text") or "{}")
|
||
kanal.bericht_speichern(bericht, aus_auftrag=True)
|
||
except (RuntimeError, ValueError):
|
||
return None
|
||
return next((g for g in bericht.get("gaeste") or [] if g.get("vmid") == vmid), None)
|
||
|
||
|
||
def pruefen(vorher: dict, nachher: dict | None, baustein: str) -> list[str]:
|
||
"""Was nach dem Update nicht stimmt (leer = grün)."""
|
||
if nachher is None:
|
||
return ["Der Gast fehlt im neuen Bericht."]
|
||
fehler = []
|
||
if nachher.get("status") != "running":
|
||
fehler.append(f"Der Gast läuft nicht ({nachher.get('status')}).")
|
||
app = apps.app_fuer((nachher.get("app") or {}).get("kennung"), nachher.get("name"))
|
||
url = apps.adresse(app, nachher.get("ip"))
|
||
if url and not inventar.erreichbar_frisch(url):
|
||
fehler.append(f"Die Weboberfläche ({url}) antwortet nicht.")
|
||
if baustein == "app":
|
||
alt, neu = (vorher.get("app") or {}).get("version"), (nachher.get("app") or {}).get("version")
|
||
if alt and neu and alt == neu:
|
||
fehler.append(f"Die App-Version ist unverändert ({alt}).")
|
||
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"]
|
||
try:
|
||
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)
|
||
nachher = _frischer_gast(lauf, vmid)
|
||
if baustein == "app" and nachher:
|
||
lauf["version_neu"] = (nachher.get("app") or {}).get("version") # fürs Protokoll
|
||
fehler = pruefen(gast, nachher, baustein)
|
||
except RuntimeError as exc:
|
||
fehler = [str(exc)]
|
||
if not fehler:
|
||
_aufraeumen(lauf, vmid, rueckweg)
|
||
_ende(lauf, "eingespielt", f"{lauf['name']}: eingespielt, Prüfung grün.")
|
||
return
|
||
if rueckweg:
|
||
try:
|
||
wie = _zurueck(lauf, vmid, rueckweg)
|
||
_ende(lauf, "zurueckgerollt",
|
||
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 rueckweg else " Es gab weder Snapshot noch Sicherung, also keinen automatischen "
|
||
"Rückweg."),
|
||
dringend=True)
|
||
|
||
|
||
def _probe_lauf(lauf: dict, gast: dict) -> None:
|
||
"""Rückweg testen: anlegen, absichtlich rot werten, zurückgehen, nachprüfen. Der Snapshot bzw. die Sicherung
|
||
bleibt danach liegen (wie nach einem echten Rückweg) — wegräumen geht auf der Seite Snapshots."""
|
||
vmid = gast["vmid"]
|
||
try:
|
||
rueckweg = _rueckweg_anlegen(lauf, gast)
|
||
except RuntimeError as exc:
|
||
_ende(lauf, "fehler", f"{lauf['name']}: Rückweg-Probe nicht begonnen — {str(exc).rstrip('.')}. "
|
||
"Am Gerät wurde nichts geändert.")
|
||
return
|
||
if not rueckweg:
|
||
_ende(lauf, "fehler", f"{lauf['name']}: Für dieses Gerät gibt es keinen Rückweg (weder Snapshot noch "
|
||
"Sicherung) — die Probe ist nicht möglich.")
|
||
return
|
||
lauf["schritte"].append("Prüfung absichtlich auf Rot gesetzt (Probe, kein Update).")
|
||
_merken(lauf)
|
||
try:
|
||
wie = _zurueck(lauf, vmid, rueckweg)
|
||
time.sleep(WARTEN_NACH_UPDATE_S)
|
||
fehler = pruefen(gast, _frischer_gast(lauf, vmid), "probe")
|
||
except RuntimeError as exc:
|
||
wie, fehler = "", [str(exc)]
|
||
if fehler:
|
||
_ende(lauf, "fehler", f"{lauf['name']}: Rückweg-Probe rot — {' '.join(fehler)}", dringend=True)
|
||
return
|
||
_ende(lauf, "probe-gruen", f"{lauf['name']}: Rückweg-Probe grün — {wie}, danach läuft das Gerät und antwortet.")
|
||
|
||
|
||
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. 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 and name not in per_knopf:
|
||
try:
|
||
_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 _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:
|
||
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.")
|
||
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)
|
||
# Anders als bei den Containern bleibt auch dieser nicht stehen: Die VM schreibt laufend (Docker, Rippy),
|
||
# ein Snapshot wüchse im Thin-Pool bis zum nächsten Update mit. Sein Zweck war der Weg zurück bei Rot.
|
||
try:
|
||
_auftrag(lauf, "snapshot_loeschen", {"vmid": gast["vmid"], "snapshot": rueckweg[1]}, ZEITLIMIT_KURZ_S)
|
||
except RuntimeError:
|
||
lauf["schritte"].append(f"Snapshot {rueckweg[1]} blieb stehen.")
|
||
_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:
|
||
try:
|
||
if lauf["baustein"] == "kernel":
|
||
# Welche Kernel gehen, bestimmt der Ausführer selbst (nie der laufende oder der nächste).
|
||
a = _auftrag(lauf, "kernel_aufraeumen", {}, ZEITLIMIT_SICHERUNG_S)
|
||
werte = dict(z.split("=", 1) for z in str(a.get("text") or "").splitlines()[:2] if "=" in z)
|
||
anzahl, frei = int(werte.get("entfernt") or 0), int(werte.get("frei") or 0)
|
||
_auftrag(lauf, "bericht", {}, 5 * 60)
|
||
_ende(lauf, "aufgeraeumt", f"Proxmox-Host: {anzahl} alte Kernel entfernt, "
|
||
f"{frei / 1e9:.1f} GB frei geworden.".replace(".", ",", 1)
|
||
if anzahl else "Proxmox-Host: kein alter Kernel zu entfernen.")
|
||
return
|
||
if lauf["baustein"] == "neustart":
|
||
_auftrag(lauf, "host_neustart", {}, 60)
|
||
_ende(lauf, "neustart", "Der Proxmox-Host startet neu. Die KI-Box meldet, ob alles wiederkommt.")
|
||
return
|
||
_auftrag(lauf, "host_update", {}, 60 * 60)
|
||
_auftrag(lauf, "bericht", {}, 5 * 60)
|
||
_ende(lauf, "eingespielt", "Proxmox-Host: Pakete eingespielt. Ein Neustart ist ein eigener Knopf.")
|
||
except RuntimeError as exc:
|
||
was = "Kernel aufräumen" if lauf["baustein"] == "kernel" else "Update"
|
||
_ende(lauf, "fehler", f"Proxmox-Host: {was} gescheitert — {exc}", dringend=True)
|
||
|
||
|
||
def _ende(lauf: dict, ergebnis: str, text: str, dringend: bool = False) -> None:
|
||
# Schritt von „Alle aktualisieren“: Den Erfolg sagt die Sammelmeldung am Ende; Fehler gehen sofort raus.
|
||
still = bool(lauf.get("sammellauf")) and ergebnis == "eingespielt" and not dringend
|
||
lauf.update(status="fertig", ergebnis=ergebnis, text=text, ende=time.time(), dringend=dringend,
|
||
gemeldet=not still)
|
||
_merken(lauf)
|
||
# Eine Rückweg-Probe ist kein Update: Sie steht im Protokoll, nicht im Update-Verlauf.
|
||
if lauf.get("baustein") != "probe":
|
||
try:
|
||
# Die Schritte eines Sammellaufs stehen im Update-Verlauf als EIN Lauf (gleicher Beginn, eigener Anlass).
|
||
start = datetime.fromtimestamp(lauf.get("sammellauf_start") or lauf["start"], LOCAL_TZ)
|
||
anlass = "Alle aktualisieren" if lauf.get("sammellauf") else "Update von Hand"
|
||
update_verlauf.eintragen(start.isoformat(timespec="seconds"), anlass, lauf["ziel"], ergebnis, text)
|
||
except Exception:
|
||
log.warning("homelab: Verlauf nicht geschrieben", exc_info=True)
|
||
if not still:
|
||
_melden(text, dringend=dringend)
|
||
|
||
|
||
def _neuer_lauf(ziel_id: str, baustein: str, name: str, sammellauf: dict | None = None, **mehr: object) -> dict:
|
||
lauf = {"id": uuid.uuid4().hex[:12], "ziel": ziel_id, "baustein": baustein, "name": name, "status": "laeuft",
|
||
"start": time.time(), "ende": None, "ergebnis": None, "text": None, "schritte": [], **mehr}
|
||
if sammellauf:
|
||
lauf.update(sammellauf=sammellauf["id"], sammellauf_start=sammellauf["start"])
|
||
_merken(lauf)
|
||
return lauf
|
||
|
||
|
||
def starten(ziel_id: str, baustein: str, sammellauf: dict | None = None) -> dict:
|
||
"""Knopf „Jetzt updaten“. Rückgabe {"ok": True, "lauf": id} oder {"ok": False, "detail": …}.
|
||
|
||
sammellauf ({"id", "start"}) setzt nur „Alle aktualisieren“ (sammellauf.py) für seine Schritte; ohne ihn lehnt
|
||
der Knopf ab, solange ein Sammellauf läuft."""
|
||
if baustein not in ("app", "os", "pakete", "neustart", "docker", "kernel", "probe"):
|
||
return {"ok": False, "detail": "Unbekannter Baustein."}
|
||
with START_SPERRE:
|
||
if sammellauf is None and _sammellauf_laeuft():
|
||
return {"ok": False, "detail": SAMMELLAUF_SPERRE}
|
||
if laeuft(ziel_id):
|
||
return {"ok": False, "detail": "Für dieses Gerät läuft schon ein Update."}
|
||
if ziel_id == "pve" and baustein == "probe":
|
||
return {"ok": False, "detail": "Für den Proxmox-Host gibt es keinen Rückweg zum Testen."}
|
||
if ziel_id == "pve":
|
||
name, gast = "Proxmox-Host", None
|
||
host = ((kanal.bericht() or {}).get("bericht") or {}).get("host") or {}
|
||
mehr = ({"pakete": len(host.get("updates") or [])} if baustein == "pakete"
|
||
else {"kernel": len(host.get("kernel_alt") or [])} if baustein == "kernel" else {})
|
||
else:
|
||
gast = inventar.gast(ziel_id)
|
||
if not gast:
|
||
return {"ok": False, "detail": "Dieses Gerät steht nicht im Bericht des Ausführers."}
|
||
if baustein == "docker":
|
||
app = apps.app_fuer(None, gast.get("name"))
|
||
basis = (apps.adresse(app, gast.get("ip")) or "").rstrip("/")
|
||
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, gast), name=f"homelab-{ziel_id}",
|
||
daemon=True).start()
|
||
return {"ok": True, "lauf": lauf["id"]}
|
||
if not gast.get("erlaubt"):
|
||
return {"ok": False, "detail": "Dieses Gerät ist nicht freigegeben (Etikett watcher fehlt)."}
|
||
app = apps.app_fuer((gast.get("app") or {}).get("kennung"), gast.get("name"))
|
||
name = app.name if app else str(gast.get("name"))
|
||
if baustein == "probe":
|
||
if not (gast.get("snapshot_moeglich") or gast.get("sicherung_moeglich")):
|
||
return {"ok": False, "detail": f"{name} hat keinen Rückweg (weder Snapshot noch Sicherung)."}
|
||
lauf = _neuer_lauf(ziel_id, baustein, name, None)
|
||
threading.Thread(target=_probe_lauf, args=(lauf, gast), name=f"homelab-{ziel_id}",
|
||
daemon=True).start()
|
||
return {"ok": True, "lauf": lauf["id"]}
|
||
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}
|
||
# Was vorher war, fürs Protokoll: die App-Version bzw. die Zahl der Pakete.
|
||
mehr = ({"version_alt": (gast.get("app") or {}).get("version")} if baustein == "app"
|
||
else {"pakete": (gast.get("os_updates") or {}).get("anzahl")})
|
||
lauf = _neuer_lauf(ziel_id, baustein, name, sammellauf, **mehr)
|
||
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()
|
||
return {"ok": True, "lauf": lauf["id"]}
|