244 lines
9.6 KiB
Python
244 lines
9.6 KiB
Python
"""Schnittstellen des Homelab-Teils (Rolle homelab, Phase 3/4, 24.09.2026).
|
|
|
|
GET /api/homelab/ziele Proxmox-Host und Gäste im gemeinsamen Ziel-Modell
|
|
POST /api/homelab/ziele/{id}/update „Jetzt updaten“ (App bzw. Host-Pakete)
|
|
POST /api/homelab/ziele/{id}/os-update Pakete im Gast einspielen
|
|
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/hinweise Hinweise des Wächters dieser Instanz
|
|
GET /api/homelab/ausfuehrer Lebenszeichen des Ausführers
|
|
GET /api/homelab/ausfuehrer/auftrag ┐
|
|
POST /api/homelab/ausfuehrer/bericht ├ nur für den Ausführer (Kopfzeile X-MC2-Ausfuehrer)
|
|
POST /api/homelab/ausfuehrer/ergebnis/{id} ┘
|
|
|
|
GET /api/stream Live-Strom dieser Instanz (Anstöße, kein Messpunkt)
|
|
|
|
Dünn: die Logik liegt in services/homelab/.
|
|
"""
|
|
|
|
import asyncio
|
|
import json
|
|
import time
|
|
|
|
from fastapi import APIRouter, Depends, Header, HTTPException, Request
|
|
from fastapi.responses import StreamingResponse
|
|
from kern.einstellungen import einstellungen
|
|
from pydantic import BaseModel
|
|
from services.homelab import inventar, kanal, updates
|
|
|
|
router = APIRouter(prefix="/api/homelab", tags=["homelab"])
|
|
strom_router = APIRouter(prefix="/api", tags=["homelab"])
|
|
|
|
|
|
def _nur_ausfuehrer(x_mc2_ausfuehrer: str | None = Header(default=None)) -> None:
|
|
if not kanal.token_gueltig(x_mc2_ausfuehrer):
|
|
raise HTTPException(status_code=403, detail="Nur für den Ausführer auf dem Proxmox-Host.")
|
|
kanal.kontakt()
|
|
|
|
|
|
@router.get("/ziele")
|
|
def ziele() -> dict:
|
|
return inventar.ziele()
|
|
|
|
|
|
def _antwort(ergebnis: dict) -> dict:
|
|
if not ergebnis.get("ok"):
|
|
raise HTTPException(status_code=409, detail=ergebnis.get("detail") or "Das geht gerade nicht.")
|
|
return ergebnis
|
|
|
|
|
|
@router.post("/ziele/{ziel_id}/update")
|
|
def update(ziel_id: str) -> dict:
|
|
return _antwort(updates.starten(ziel_id, "pakete" if ziel_id == "pve" else "app"))
|
|
|
|
|
|
@router.post("/ziele/{ziel_id}/os-update")
|
|
def os_update(ziel_id: str) -> dict:
|
|
return _antwort(updates.starten(ziel_id, "os"))
|
|
|
|
|
|
@router.post("/ziele/{ziel_id}/docker")
|
|
def docker(ziel_id: str) -> dict:
|
|
"""Docker über Arcanes Updater — zuerst nur als Probelauf (MC_ARCANE_ECHT=1 macht es echt)."""
|
|
return _antwort(updates.starten(ziel_id, "docker"))
|
|
|
|
|
|
@router.post("/ziele/pve/neustart")
|
|
def host_neustart() -> dict:
|
|
return _antwort(updates.starten("pve", "neustart"))
|
|
|
|
|
|
@router.post("/ziele/{ziel_id}/suchen")
|
|
def suchen(ziel_id: str) -> dict:
|
|
gast = inventar.gast(ziel_id)
|
|
if not gast or not gast.get("erlaubt"):
|
|
raise HTTPException(status_code=404, detail="Dieses Gerät steht nicht (freigegeben) im Bericht.")
|
|
return {"ok": True, "auftrag": kanal.anlegen("suchen", {"vmid": gast["vmid"]})}
|
|
|
|
|
|
@router.get("/hinweise")
|
|
def hinweise() -> dict:
|
|
"""Was der Wächter dieser Instanz gerade sieht (Ausführer schweigt, Gast antwortet nicht …)."""
|
|
from services import waechter
|
|
return waechter.lese_stand()
|
|
|
|
|
|
@router.get("/laeufe")
|
|
def laeufe() -> dict:
|
|
return {"laeufe": updates.laeufe()}
|
|
|
|
|
|
# --- „Alle aktualisieren“, Protokoll, Einstellungen (24.09.2026) ------------------------------------------------
|
|
# GET /api/homelab/alle/plan was „Alle aktualisieren“ täte, in dieser Reihenfolge
|
|
# POST /api/homelab/alle „Alle aktualisieren“ starten
|
|
# GET /api/homelab/sammellauf der laufende oder der letzte Sammellauf
|
|
# GET /api/homelab/protokoll?grenze=200&berichte=0 was wann geschah, neueste zuerst
|
|
# GET /api/homelab/einstellungen Arcane (Schlüssel, echt), Wartezeit, Ausführer
|
|
# POST /api/homelab/einstellungen/arcane-schluessel {"schluessel": …}: erst gegen Arcane prüfen, dann speichern
|
|
# DELETE /api/homelab/einstellungen/arcane-schluessel
|
|
# POST /api/homelab/einstellungen/arcane-echt {"an": bool}: echte Docker-Updates statt Probelauf
|
|
# Was nicht geht, beantworten sie mit {"ok": false, "detail": …} und HTTP 200, wie der Telegram-Test (die Oberfläche
|
|
# liest ok). Die Dienste laden die Endpunkte selbst, wie hinweise().
|
|
|
|
@router.get("/alle/plan")
|
|
def alle_plan() -> dict:
|
|
from services.homelab import sammellauf
|
|
return sammellauf.plan()
|
|
|
|
|
|
@router.post("/alle")
|
|
def alle_starten() -> dict:
|
|
from services.homelab import sammellauf
|
|
return sammellauf.starten()
|
|
|
|
|
|
@router.get("/sammellauf")
|
|
def sammellauf_stand() -> dict:
|
|
from services.homelab import sammellauf
|
|
return {"sammellauf": sammellauf.aktueller()}
|
|
|
|
|
|
@router.get("/protokoll")
|
|
def protokoll_lesen(grenze: int = 200, berichte: bool = False) -> dict:
|
|
from services.homelab import protokoll
|
|
return {"eintraege": protokoll.eintraege(grenze, berichte)}
|
|
|
|
|
|
@router.get("/einstellungen")
|
|
def einstellungen_stand() -> dict:
|
|
from services.homelab import einstellungen as homelab_einstellungen
|
|
return homelab_einstellungen.stand()
|
|
|
|
|
|
@router.post("/einstellungen/arcane-schluessel")
|
|
async def arcane_schluessel_setzen(request: Request) -> dict:
|
|
"""Den Body liest der Dienst selbst: Ein Pydantic-Modell würde bei falscher Form mit 422 antworten und die
|
|
Eingabe, also den Schlüssel, dabei wiederholen."""
|
|
from services.homelab import einstellungen as homelab_einstellungen
|
|
wert = homelab_einstellungen.schluessel_aus_body(await request.body())
|
|
return await asyncio.to_thread(homelab_einstellungen.arcane_schluessel_setzen, wert)
|
|
|
|
|
|
@router.delete("/einstellungen/arcane-schluessel")
|
|
def arcane_schluessel_loeschen() -> dict:
|
|
from services.homelab import einstellungen as homelab_einstellungen
|
|
return homelab_einstellungen.arcane_schluessel_loeschen()
|
|
|
|
|
|
class ArcaneEcht(BaseModel):
|
|
an: bool
|
|
|
|
|
|
@router.post("/einstellungen/arcane-echt")
|
|
def arcane_echt(schalter: ArcaneEcht) -> dict:
|
|
from services.homelab import einstellungen as homelab_einstellungen
|
|
return homelab_einstellungen.arcane_echt_setzen(schalter.an)
|
|
|
|
|
|
@router.get("/ausfuehrer")
|
|
def ausfuehrer() -> dict:
|
|
zuletzt = kanal.zuletzt()
|
|
return {"zuletzt": zuletzt, "verbunden": bool(zuletzt and time.time() - zuletzt < inventar.BERICHT_ALT_S),
|
|
"auftraege": kanal.liste()[:20]}
|
|
|
|
|
|
@router.get("/ausfuehrer/auftrag", dependencies=[Depends(_nur_ausfuehrer)])
|
|
def auftrag_abholen() -> dict:
|
|
return kanal.naechster() or {}
|
|
|
|
|
|
@router.post("/ausfuehrer/bericht", dependencies=[Depends(_nur_ausfuehrer)])
|
|
def bericht(daten: dict) -> dict:
|
|
kanal.bericht_speichern(daten)
|
|
return {"ok": True}
|
|
|
|
|
|
class Ergebnis(BaseModel):
|
|
code: int
|
|
text: str = ""
|
|
|
|
|
|
@router.post("/ausfuehrer/ergebnis/{auftrag_id}", dependencies=[Depends(_nur_ausfuehrer)])
|
|
def ergebnis(auftrag_id: str, e: Ergebnis) -> dict:
|
|
return {"ok": kanal.ergebnis(auftrag_id, e.code, e.text)}
|
|
|
|
|
|
# --- Live-Strom der Homelab-Instanz ---------------------------------------------------------------
|
|
# Die Oberfläche hört auf /api/stream der Instanz, die sie ausliefert. Im Homelab gibt es keine
|
|
# Messpunkte der KI-Box; der Strom stößt nur neu laden an, wenn sich Bericht, Läufe oder Hinweise ändern,
|
|
# und meldet sich alle 10 s mit einem leeren Anstoß (sonst hielte die Oberfläche die Leitung für tot).
|
|
_DATEIEN = (("homelab", "pve-bericht.json"), ("homelab-laeufe", "homelab-laeufe.json"),
|
|
("homelab-hinweise", "mc2-waechter.json"))
|
|
|
|
|
|
def _abdruecke() -> dict[str, float]:
|
|
ordner = einstellungen().daten_dir
|
|
abdruck = {}
|
|
for schluessel, name in _DATEIEN:
|
|
try:
|
|
abdruck[schluessel] = (ordner / name).stat().st_mtime
|
|
except OSError:
|
|
abdruck[schluessel] = 0.0
|
|
return abdruck
|
|
|
|
|
|
async def _strom(request: Request, takt_s: float = 2.0, lebenszeichen_takte: int = 5):
|
|
alt = _abdruecke()
|
|
yield ": verbunden\n\n"
|
|
takte = 0
|
|
while not await request.is_disconnected():
|
|
await asyncio.sleep(takt_s)
|
|
takte += 1
|
|
neu = _abdruecke()
|
|
schluessel = [k for k, v in neu.items() if v != alt.get(k)]
|
|
alt = neu
|
|
if schluessel or takte % lebenszeichen_takte == 0:
|
|
yield f"event: invalidate\ndata: {json.dumps({'keys': schluessel})}\n\n"
|
|
|
|
|
|
@strom_router.get("/stream")
|
|
async def stream(request: Request) -> StreamingResponse:
|
|
return StreamingResponse(_strom(request), media_type="text/event-stream",
|
|
headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"})
|
|
|
|
|
|
# --- Messwerte mit Verlauf (Monitoring, seit 24.09.2026) ------------------------------------------------------
|
|
# POST /api/homelab/ausfuehrer/messwerte jede Minute vom Ausführer (Kopfzeile X-MC2-Ausfuehrer)
|
|
# GET /api/homelab/messwerte?zeitraum=1h|24h|7d Proxmox-Host und Gäste: Reihen und letzter Punkt
|
|
# Die Logik liegt in services/homelab/messwerte.py, die Ablage in kern/messreihen.py.
|
|
|
|
@router.post("/ausfuehrer/messwerte", dependencies=[Depends(_nur_ausfuehrer)])
|
|
def messwerte_annehmen(daten: dict) -> dict:
|
|
from services.homelab import messwerte as homelab_messwerte
|
|
return {"ok": True, "geraete": homelab_messwerte.annehmen(daten)}
|
|
|
|
|
|
@router.get("/messwerte")
|
|
def messwerte_lesen(zeitraum: str = "1h") -> dict:
|
|
from services.homelab import messwerte as homelab_messwerte
|
|
if zeitraum not in homelab_messwerte.ZEITRAEUME:
|
|
raise HTTPException(status_code=400, detail="Den Zeitraum gibt es nicht; möglich sind 1h, 24h und 7d.")
|
|
return homelab_messwerte.abfrage(zeitraum)
|