feat(auftraege): worker, Phasen und Live-Fortschritt per SSE

Aufträge laufen als pg-boss-Jobs im worker. Der Phasen-Runner der Engine kennt weder Proxmox noch Datenbank; eine Senke schreibt Phasen und Log in die DB und meldet per NOTIFY, die app streamt per SSE an Web und CLI (Last-Event-ID, Herzschlag, Polling-Fallback im Browser). VMIDs vergibt eine Advisory-Sperre je Server zusammen mit einer Reservierungstabelle; zehn parallele Reservierungen im Test bekommen zehn verschiedene IDs. Der Proxmox-Client hat einen Trockenmodus für den Dry-Run: Lesendes echt, Schreibendes nur aufgezeichnet. Live-Ansicht im Aufbau der CLI-Ausgabe. Im echten Betrieb aufgefallen: ssh2 und pg sind CommonJS und brauchen im worker Default-Importe. Closes #006 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-12 10:54:41 +02:00
parent 01d22aac3a
commit 76bc0e4269
38 changed files with 2274 additions and 22 deletions
@@ -0,0 +1,191 @@
+import { randomInt } from "node:crypto";
+import type { Auftrag, Prisma } from "@/generated/prisma/client";
+import type { AuftragsArt, GastTyp, Quelle } from "@/generated/prisma/enums";
+import { prisma } from "@/lib/db";
+import type { Aufrufer } from "@/server/auth/zugang";
+import { AnwendungsFehler, nichtGefunden } from "@/server/fehler";
+import { melden } from "@/server/ereignisse/senke";
+import { protokollieren } from "@/server/services/protokoll";
+import { auftragEinstellen } from "@/server/warteschlange";
+import type { AuftragSicht, LogZeile } from "@/lib/schemas/auftrag";
+
+export type { AuftragSicht, LogZeile };
+
+/** Kurz-IDs ohne Verwechsler (kein 0/o, 1/l/i): „d-7f3k2“ für Ausrollen, „t-…“ für Templates. */
+const ZEICHEN = "23456789abcdefghjkmnpqrstuvwxyz";
+const PRAEFIX: Record<AuftragsArt, string> = { AUSROLLEN: "d", TEMPLATE_BAUEN: "t", AUFRAEUMEN: "c" };
+
+export function kurzIdErzeugen(art: AuftragsArt): string {
+  let id = "";
+  for (let i = 0; i < 5; i += 1) id += ZEICHEN[randomInt(ZEICHEN.length)];
+  return `${PRAEFIX[art]}-${id}`;
+}
+
+export type NeuerAuftrag = {
+  art: AuftragsArt;
+  serverId: string;
+  knoten?: string;
+  gastTyp?: GastTyp;
+  name?: string;
+  distributionId?: string;
+  profile?: string[];
+  anfrage: Prisma.InputJsonValue;
+  plan?: Prisma.InputJsonValue;
+  bezugId?: string;
+  wiederholtVonId?: string;
+};
+
+export async function auftragAnlegen(
+  neu: NeuerAuftrag,
+  aufrufer: Aufrufer,
+  ip: string | null,
+  einstellen: (id: string) => Promise<void> = auftragEinstellen,
+): Promise<Auftrag> {
+  let auftrag: Auftrag | undefined;
+  for (let versuch = 0; versuch < 5 && !auftrag; versuch += 1) {
+    try {
+      auftrag = await prisma.$transaction(async (tx) => {
+        const angelegt = await tx.auftrag.create({
+          data: {
+            ...neu,
+            profile: neu.profile ?? [],
+            kurzId: kurzIdErzeugen(neu.art),
+            quelle: aufrufer.quelle as Quelle,
+            erstelltVonId: aufrufer.benutzer.id,
+          },
+        });
+        await protokollieren(
+          {
+            benutzerId: aufrufer.benutzer.id,
+            quelle: aufrufer.quelle,
+            aktion:
+              neu.art === "AUSROLLEN"
+                ? "Ausrollen gestartet"
+                : neu.art === "TEMPLATE_BAUEN"
+                  ? "Template-Bau gestartet"
+                  : "Aufräumen gestartet",
+            ziel: `auftrag:${angelegt.kurzId}`,
+            details: { name: neu.name, distribution: neu.distributionId },
+            ip,
+          },
+          tx,
+        );
+        return angelegt;
+      });
+    } catch (fehler) {
+      // Kurz-ID zufällig doppelt – selten, dann einfach neu würfeln.
+      if ((fehler as { code?: string }).code !== "P2002") throw fehler;
+    }
+  }
+  if (!auftrag) throw new AnwendungsFehler(500, "intern", "Konnte keine freie Auftrags-ID erzeugen.");
+  await einstellen(auftrag.id);
+  return auftrag;
+}
+
+const MIT = {
+  server: { select: { name: true, titel: true } },
+  erstelltVon: { select: { benutzername: true } },
+  phasen: { orderBy: { reihenfolge: "asc" as const } },
+};
+
+type MitBeziehungen = Prisma.AuftragGetPayload<{ include: typeof MIT }>;
+
+export function auftragSicht(a: MitBeziehungen): AuftragSicht {
+  const iso = (d: Date | null) => d?.toISOString() ?? null;
+  return {
+    id: a.id,
+    kurzId: a.kurzId,
+    art: a.art,
+    status: a.status,
+    kopf:
+      a.kopf ?? [`Server ${a.server.name}`, a.knoten ? `Node ${a.knoten}` : null].filter(Boolean).join(" · "),
+    server: a.server,
+    knoten: a.knoten,
+    gastTyp: a.gastTyp,
+    vmid: a.vmid,
+    name: a.name,
+    distributionId: a.distributionId,
+    profile: a.profile,
+    ergebnis: a.ergebnis,
+    fehler: a.fehler,
+    erstelltVon: a.erstelltVon.benutzername,
+    erstelltAm: a.erstelltAm.toISOString(),
+    gestartetAm: iso(a.gestartetAm),
+    beendetAm: iso(a.beendetAm),
+    phasen: a.phasen.map((p) => ({
+      schluessel: p.schluessel,
+      titel: p.titel,
+      status: p.status,
+      detail: p.detail,
+      ursache: p.ursache,
+      hinweis: p.hinweis,
+      gestartetAm: iso(p.gestartetAm),
+      beendetAm: iso(p.beendetAm),
+    })),
+  };
+}
+
+/** Sucht per Kurz-ID oder interner ID – die CLI nimmt, was der Benutzer tippt. */
+export async function auftragHolen(kennung: string): Promise<AuftragSicht> {
+  const auftrag = await prisma.auftrag.findFirst({
+    where: { OR: [{ kurzId: kennung }, { id: kennung }] },
+    include: MIT,
+  });
+  if (!auftrag) throw nichtGefunden(`Den Auftrag „${kennung}“`);
+  return auftragSicht(auftrag);
+}
+
+export async function auftraegeListe(
+  filter: { serverId?: string; grenze?: number } = {},
+): Promise<AuftragSicht[]> {
+  const zeilen = await prisma.auftrag.findMany({
+    where: filter.serverId ? { serverId: filter.serverId } : {},
+    include: MIT,
+    orderBy: { erstelltAm: "desc" },
+    take: filter.grenze ?? 50,
+  });
+  return zeilen.map(auftragSicht);
+}
+
+export async function logAb(auftragId: string, abId: bigint, grenze = 500): Promise<LogZeile[]> {
+  const zeilen = await prisma.logeintrag.findMany({
+    where: { auftragId, id: { gt: abId } },
+    orderBy: { id: "asc" },
+    take: grenze,
+  });
+  return zeilen.map((z) => ({
+    id: z.id.toString(),
+    zeit: z.zeit.toISOString(),
+    stufe: z.stufe,
+    phase: z.phase,
+    nachricht: z.nachricht,
+  }));
+}
+
+export const ENDZUSTAENDE = new Set(["ERFOLGREICH", "FEHLGESCHLAGEN", "ABGEBROCHEN", "AUFGERAEUMT"]);
+
+/** Bittet den worker um Abbruch; er prüft das zwischen den Phasen. */
+export async function auftragAbbrechen(
+  kennung: string,
+  aufrufer: Aufrufer,
+  ip: string | null,
+): Promise<void> {
+  const auftrag = await auftragHolen(kennung);
+  if (ENDZUSTAENDE.has(auftrag.status)) {
+    throw new AnwendungsFehler(409, "beendet", "Der Auftrag ist bereits beendet.");
+  }
+  await prisma.$transaction(async (tx) => {
+    await tx.auftrag.update({ where: { id: auftrag.id }, data: { abbrechen: true } });
+    await protokollieren(
+      {
+        benutzerId: aufrufer.benutzer.id,
+        quelle: aufrufer.quelle,
+        aktion: "Abbruch angefordert",
+        ziel: `auftrag:${auftrag.kurzId}`,
+        ip,
+      },
+      tx,
+    );
+  });
+  await melden(auftrag.id);
+}