Version 2.8.29 / Lizenzserver 2.8.5: Release-Upgrade von Ubuntu bricht den venv nicht mehr

Version 2.8.28: dynamische Lease als Client uebernehmen
Version 2.8.27: Live-Protokoll mit Stufen, Auftraege fallen nicht mehr heraus
2026-09-16 17:44:32 +02:00 · 2026-09-16 12:28:02 +02:00 · 2026-09-16 11:32:00 +02:00
25 changed files with 622 additions and 56 deletions
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "tesm"
-version = "2.8.26"
+version = "2.8.29"
 description = "TESM -- Verwaltung und Ueberwachung von PoE-Endgeraeten und Aruba-Switchen"
 requires-python = ">=3.11"
 dependencies = [
@@ -318,12 +318,16 @@ def _restart_as_job(extension: Any, conn: Any, device: Any, method: Any):  # typ
    # Der Auftrag laeuft im Hintergrund und meldet sein Ergebnis erst, wenn das
    # Geraet zurueck ist. Der Zustand muss aber sofort umschlagen -- sonst sieht
    # die Uebersicht aus wie eine, in der nichts passiert ist.
+    live = extension.registry.get("live_log")
    with transaction():
-        monitor.mark_restarting(conn, int(device["id"]))
+        monitor.mark_restarting(
+            conn, int(device["id"]), live=live, trigger="manuell", method=method.key
+        )

    maintenance_service.start_background(
        maintenance_service.run_reboot,
        database=extension.database,
+        live=live,
        job_id=handle.id,
        device=dict(device),
        username=username,
@@ -20,7 +20,7 @@ from tesm_core.auth.service import client_ip
 from tesm_core.db import Database
 from tesm_core.extension import core, db, transaction

-from ..services import kea
+from ..services import inventory, kea
 from ..permissions import DHCP_PAGE

 bp = Blueprint("dhcp", __name__, url_prefix="/dhcp")
@@ -73,6 +73,12 @@ def overview():
    # Zustand aus den laufenden Leases -- wie im Windows-DHCP.
    reservations = kea.annotate_reservations(reservations, leases)
    reserved_ips = {str(entry["ip"]) for entry in reservations}
+    # Wozu es schon einen Client gibt, ist nicht mehr zu uebernehmen -- auch
+    # wenn dessen Adresse (noch) keine Reservierung hat.
+    bekannte_macs = {
+        inventory.normalize_mac(str(zeile["mac"]))
+        for zeile in Database.all(conn, "SELECT mac FROM devices WHERE deleted_at IS NULL")
+    }

    return render_template(
        "tesm/dhcp.html",
@@ -90,6 +96,7 @@ def overview():
        manual_reservations=Database.all(conn, "SELECT * FROM dhcp_reservations ORDER BY ip"),
        leases=leases,
        reserved_ips=reserved_ips,
+        bekannte_macs=bekannte_macs,
        networks=networks,
        default_gateway=kea.default_gateway(sysops) if sysops else "",
        service=kea.service_state(sysops) if sysops else {},
@@ -447,6 +454,91 @@ def add_reservation():
    return _write_and_redirect()


+@bp.post("/lease/adopt")
+# Zwei Rechte, mit Absicht: die Uebernahme ist eine eigene Funktion, das
+# Ergebnis aber ein Client. Wer keine Clients anlegen darf, legt auch hier
+# keine an -- sonst waere diese Schaltflaeche eine Hintertuer an der
+# Geraeteverwaltung vorbei.
+@permission_required("dhcp_lease_adopt.execute", "devices.create")
+def adopt_lease():
+    """Macht aus einer dynamisch vergebenen Adresse einen ueberwachten Client.
+
+    Die Angaben kommen **nicht** aus dem Formular, sondern aus der Lease-Datei:
+    geschickt wird nur die MAC, alles Weitere liest TESM frisch nach. Damit
+    heisst "Uebernahme" auch Uebernahme -- und eine Lease, die zwischen
+    Seitenaufbau und Klick abgelaufen oder umgezogen ist, faellt auf, statt
+    stillschweigend einen falschen Datensatz anzulegen.
+    """
+    extension = core()
+    conn = db()
+    sysops = extension.sysops
+    gesucht = inventory.normalize_mac(request.form.get("mac") or "")
+    leases = kea.read_leases(sysops) if sysops else []
+    lease = next((eintrag for eintrag in leases if eintrag.mac == gesucht), None)
+    if lease is None:
+        flash(
+            "Zu dieser MAC liegt keine Lease mehr vor. Die Liste war nicht mehr aktuell.",
+            "warning",
+        )
+        return redirect(url_for("dhcp.overview"))
+
+    # Nur dynamische. Eine Adresse, die schon reserviert ist, gehoert bereits
+    # zu einem gepflegten Datensatz -- da gibt es nichts zu uebernehmen.
+    networks = kea.detect_networks(sysops) if sysops else []
+    reserviert = {
+        str(eintrag["ip"])
+        for eintrag in kea.collect_reservations(
+            conn, only_networks=kea.configured_networks(conn, networks)
+        )
+    }
+    if lease.address in reserviert:
+        flash(
+            f"{lease.address} ist bereits reserviert – diese Lease ist nicht dynamisch.",
+            "warning",
+        )
+        return redirect(url_for("dhcp.overview"))
+
+    # Der Hostname aus der Lease ist der Name, den das Geraet selbst nennt.
+    # Fehlt er, steht die Adresse da: ein Name wie "Gerät 7" sagt weniger.
+    name = (lease.hostname or "").strip() or f"Client {lease.address}"
+    try:
+        with transaction():
+            device_id = inventory.create_device(
+                conn,
+                name=name,
+                mac=lease.mac,
+                ip=lease.address,
+                switch_id=None,
+                port="",
+                credential_id=None,
+                ssh_port=None,
+                # Ohne Switch und Port gibt es keinen PoE-Neustart. Mit
+                # eingeschaltetem Automatismus schriebe die Ueberwachung bei
+                # jedem Ausfall einen Fehlschlag ins Protokoll, den niemand
+                # abstellen kann. Einschalten kann man ihn, sobald der Port
+                # eingetragen ist.
+                auto_restart=False,
+                actor=current_user.username,
+            )
+    except inventory.ValidationError as exc:
+        flash(str(exc), "danger")
+        return redirect(url_for("dhcp.overview"))
+
+    _audit(
+        "device.created",
+        name,
+        f"aus dynamischer Lease {lease.address} ({lease.mac}) übernommen",
+        severity="notice",
+    )
+    flash(
+        f"{name} wurde als Client übernommen. Switch, Port und Zugangsdaten fehlen noch – "
+        "ohne sie gibt es keinen PoE-Neustart und keine Wartung. Die feste Adresse entsteht "
+        "beim nächsten Schreiben der DHCP-Konfiguration.",
+        "success",
+    )
+    return redirect(url_for("devices.detail", device_id=device_id))
+
+
@bp.post("/reservation/<int:reservation_id>/delete")
@permission_required("dhcp_reservations.delete")
 def delete_reservation(reservation_id: int):
@@ -66,4 +66,5 @@ def restarts():
        method=method,
        methods=tuple(monitor.METHOD_LABELS.items()),
        method_labels=monitor.METHOD_LABELS,
+        trigger_labels=monitor.TRIGGER_LABELS,
    )
@@ -83,6 +83,7 @@ def overview():  # noqa: C901 - eine Seite, drei Aufgaben
        "tesm/maintenance.html",
        devices=_eligible_devices(conn),
        jobs=service.list_jobs(conn),
+        auftragslage=service.letzter_auftrag_je_geraet(conn),
        category_labels=dict(inventory.CREDENTIAL_CATEGORIES),
        category_effects=inventory.CATEGORY_EFFECTS,
        update_category=inventory.MAINTENANCE_CATEGORY,
@@ -145,7 +146,7 @@ def install_windows_tool():
 def status():
    """Zustand der Auftraege -- aus der Datenbank, nicht aus dem Prozessspeicher."""
    conn = db()
-    jobs = service.list_jobs(conn, limit=30)
+    jobs = service.laufende_und_letzte(conn, limit=30)
    running = any(job["state"] in {"pending", "running"} for job in jobs)
    return jsonify(
        {
@@ -282,27 +283,35 @@ def _start(kind: str, befehl: str = "") -> None:
                timeout=int(extension.settings.get(conn, "maintenance_command_timeout") or 900),
            )
        else:
+            weg = (
+                service.METHOD_RPC
+                if str(device["category"]) == inventory.NON_SSH_CATEGORY
+                else service.METHOD_SSH
+            )
            # Sofort sichtbar, nicht erst wenn das Geraet zurueck ist.
            with transaction() as verbindung:
-                monitor.mark_restarting(verbindung, int(device["id"]))
+                monitor.mark_restarting(
+                    verbindung,
+                    int(device["id"]),
+                    live=extension.registry.get("live_log"),
+                    trigger="maintenance",
+                    method=weg,
+                )
            service.start_background(
                service.run_reboot,
                database=extension.database,
+                live=extension.registry.get("live_log"),
                job_id=handle.id,
                device=dict(device),
                username=username,
                password=password,
                wait_seconds=int(extension.settings.get(conn, "maintenance_reboot_wait") or 300),
                actor=current_user.username,
-                # Hier steht in ``category`` die Kategorie der *Zugangsdaten*
-                # (siehe _query_devices) -- daraus folgt der Weg. Uebergeben
-                # statt in run_reboot erraten: dort bedeutet derselbe
-                # Schluessel je Herkunft etwas anderes.
-                method=(
-                    service.METHOD_RPC
-                    if str(device["category"]) == inventory.NON_SSH_CATEGORY
-                    else service.METHOD_SSH
-                ),
+                # Der Weg steht oben: in ``category`` liegt die Kategorie der
+                # *Zugangsdaten* (siehe _query_devices), daraus folgt er.
+                # Uebergeben statt in run_reboot erraten -- dort bedeutet
+                # derselbe Schluessel je Herkunft etwas anderes.
+                method=weg,
            )
        started += 1

@@ -128,7 +128,7 @@ NAVIGATION = NavTree(
            children=(
                NavItem(
                    key="logs_live",
-                    label="Laufend",
+                    label="Live",
                    icon="terminal",
                    endpoint="logs.live",
                    permissions=("logs_live.read",),
@@ -264,6 +264,31 @@ DHCP_SERVICE = Resource(
    action_hints={A.EXECUTE: "Dienstzustand ändern."},
 )

+#: Eine dynamische Lease in einen Client verwandeln.
+#:
+#: Eigene Zeile, weil es eine eigene Entscheidung ist: hier wird aus einer
+#: Beobachtung ("dieses Geraet hat sich eine Adresse geholt") ein gepflegter
+#: Datensatz, den die Ueberwachung ab sofort anpingt und der beim naechsten
+#: Schreiben der Konfiguration eine feste Adresse bekommt. Wer Leases sehen
+#: darf, soll deshalb nicht automatisch welche uebernehmen duerfen.
+#:
+#: **Und es reicht allein nicht.** Die Uebernahme legt einen Client an, also
+#: verlangt die Route zusaetzlich "Clients: Anlegen". Sonst waere dies eine
+#: Hintertuer an der Geraeteverwaltung vorbei -- dieselbe Wirkung, anderes
+#: Formular. Beide Haken zusammen, oder die Schaltflaeche erscheint nicht.
+DHCP_LEASE_ADOPT = Resource(
+    key="dhcp_lease_adopt",
+    parent="dhcp_subnets",
+    label="DHCP: Lease als Client übernehmen",
+    actions=(A.READ, A.EXECUTE),
+    hint="Aus einer dynamisch vergebenen Adresse einen überwachten Client machen",
+    action_hints={
+        A.READ: "Die Schaltfläche an dynamischen Leases sehen.",
+        A.EXECUTE: "Client aus der Lease anlegen. Verlangt zusätzlich "
+        "'Clients: Anlegen' – es entsteht ein Gerätedatensatz.",
+    },
+)
+
 #: Die DHCP-Seite zeigt alle Abschnitte; jeder Abschnitt haengt an seiner
 #: eigenen Zeile. Geoeffnet wird sie, wer einen davon sehen darf.
 DHCP_PAGE: tuple[str, ...] = (
@@ -380,7 +405,14 @@ NETWORK_AREA = Area(
    key="network",
    label="Netzwerkdienste",
    icon="network",
-    resources=(DHCP_SUBNETS, DHCP_OPTIONS, DHCP_RESERVATIONS, DHCP_CONFIG, DHCP_SERVICE),
+    resources=(
+        DHCP_SUBNETS,
+        DHCP_OPTIONS,
+        DHCP_RESERVATIONS,
+        DHCP_LEASE_ADOPT,
+        DHCP_CONFIG,
+        DHCP_SERVICE,
+    ),
 )

 FILES_AREA = Area(
@@ -29,7 +29,7 @@ import sqlite3
 import threading
 import time
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from typing import Any, Callable

 from tesm_core import audit
@@ -284,11 +284,81 @@ def list_jobs(
    placeholders = ",".join("?" * len(kinds))
    return Database.all(
        conn,
-        f"SELECT * FROM jobs WHERE kind IN ({placeholders}) ORDER BY created_at DESC LIMIT ?",
+        # ``rowid`` als zweites Ordnungsmerkmal: ``created_at`` hat
+        # Sekundenaufloesung, und ein Massenbefehl legt vierzig Auftraege in
+        # derselben Sekunde an. Ohne das entschied bei Gleichstand die
+        # Speicherreihenfolge -- die Liste sah bei jedem Aufruf anders aus.
+        f"SELECT * FROM jobs WHERE kind IN ({placeholders}) "
+        "ORDER BY created_at DESC, rowid DESC LIMIT ?",
        (*kinds, limit),
    )


+def laufende_und_letzte(
+    conn: sqlite3.Connection,
+    *,
+    kinds: tuple[str, ...] = (JOB_KIND_UPDATE, JOB_KIND_REBOOT, JOB_KIND_COMMAND),
+    limit: int = 30,
+) -> list[dict[str, Any]]:
+    """Alles, was laeuft oder eben fertig wurde -- und dazu die letzten Auftraege.
+
+    Fuer die Statusabfrage der Wartungsseite. Eine feste Obergrenze allein
+    reicht dort nicht, und das war ein echter Fehler: ein Massenbefehl auf
+    vierzig Geraete legt vierzig Auftraege an, ``LIMIT 30`` schnitt zehn davon
+    ab -- und weil alle denselben Zeitstempel auf die Sekunde tragen, waren es
+    zehn willkuerliche. Auf der Seite sah das aus, als haetten die letzten
+    Geraete den Befehl nie bekommen: sie liefen, ihre Ausgabe kam nur nie an.
+
+    Was laeuft, faellt hier deshalb nie heraus, und was gerade fertig wurde,
+    behaelt seine letzten Zeilen so lange wie ``eben_fertig`` es zusagt.
+    """
+    platzhalter = ",".join("?" * len(kinds))
+    schwelle = (
+        datetime.now(timezone.utc) - timedelta(seconds=EBEN_FERTIG_SEKUNDEN)
+    ).isoformat(timespec="seconds")
+    gesammelt: dict[str, dict[str, Any]] = {}
+    for sql, params in (
+        (
+            f"SELECT * FROM jobs WHERE kind IN ({platzhalter}) "
+            "AND state IN ('pending','running') ORDER BY created_at DESC, rowid DESC",
+            (*kinds,),
+        ),
+        (
+            f"SELECT * FROM jobs WHERE kind IN ({platzhalter}) "
+            "AND COALESCE(finished_at, updated_at) >= ? ORDER BY created_at DESC, rowid DESC",
+            (*kinds, schwelle),
+        ),
+        (
+            f"SELECT * FROM jobs WHERE kind IN ({platzhalter}) "
+            "ORDER BY created_at DESC, rowid DESC LIMIT ?",
+            (*kinds, limit),
+        ),
+    ):
+        for job in Database.all(conn, sql, params):
+            gesammelt.setdefault(str(job["id"]), job)
+    return sorted(
+        gesammelt.values(), key=lambda job: str(job["created_at"] or ""), reverse=True
+    )
+
+
+def letzter_auftrag_je_geraet(
+    conn: sqlite3.Connection,
+    *,
+    kinds: tuple[str, ...] = (JOB_KIND_UPDATE, JOB_KIND_REBOOT, JOB_KIND_COMMAND),
+    limit: int = 400,
+) -> dict[str, dict[str, Any]]:
+    """Zu jedem Geraetenamen sein neuester Auftrag.
+
+    Damit die Wartungsseite schon beim Aufbau zeigt, was wo laeuft -- und nicht
+    erst, wenn die erste Statusabfrage zurueck ist. Der Schluessel ist der
+    Name, denn genau den traegt ein Auftrag als ``subject``.
+    """
+    stand: dict[str, dict[str, Any]] = {}
+    for job in list_jobs(conn, kinds=kinds, limit=limit):
+        stand.setdefault(str(job["subject"]), job)
+    return stand
+
+
 def get_job(conn: sqlite3.Connection, job_id: str) -> dict[str, Any] | None:
    return Database.one(conn, "SELECT * FROM jobs WHERE id=?", (job_id,))

@@ -648,6 +718,7 @@ def _reboot_windows(
    actor: str,
    emit: Callable[[str], None],
    elapsed: Callable[[], int],
+    live: Any = None,
 ) -> bool:
    """Neustart eines Windows-Geraets ueber RPC. ``True`` = weiter warten.

@@ -678,6 +749,7 @@ def _reboot_windows(
        duration_ms=elapsed(),
        detail=detail,
        method=METHOD_RPC,
+        live=live,
    )
    return False

@@ -692,6 +764,7 @@ def run_reboot(
    wait_seconds: int,
    actor: str = "system",
    method: str = METHOD_SSH,
+    live: Any = None,
 ) -> None:
    """Loest einen Neustart aus und wartet auf die Rueckkehr.

@@ -744,6 +817,7 @@ def run_reboot(
            actor=actor,
            emit=emit,
            elapsed=elapsed,
+            live=live,
        ):
            return
    else:
@@ -767,6 +841,7 @@ def run_reboot(
                duration_ms=elapsed(),
                detail=str(exc),
                method=method,
+                live=live,
            )
            return

@@ -809,6 +884,7 @@ def run_reboot(
                duration_ms=elapsed(),
                detail=problem,
                method=method,
+                live=live,
            )
            return

@@ -849,6 +925,7 @@ def run_reboot(
                duration_ms=elapsed(),
                detail="Neustart über SSH, Gerät ist zurückgekehrt.",
                method=method,
+                live=live,
            )
            return
        time.sleep(REBOOT_POLL_SECONDS)
@@ -873,6 +950,7 @@ def run_reboot(
            f"{wait_seconds}s nicht wieder geantwortet."
        ),
        method=method,
+        live=live,
    )


@@ -885,6 +963,7 @@ def _log_restart(
    duration_ms: int,
    detail: str,
    method: str = METHOD_SSH,
+    live: Any = None,
 ) -> None:
    """Traegt den Neustart in die geraeteweite Neustart-Historie ein.

@@ -907,6 +986,7 @@ def _log_restart(
                duration_ms=duration_ms,
                detail=detail,
                method=method,
+                live=live,
            )
    except Exception:  # noqa: BLE001 - Protokollieren darf den Auftrag nie kippen
        logger.exception("Neustart konnte nicht protokolliert werden (Gerät %s)", device_id)
@@ -156,6 +156,16 @@ class LiveLog:
    def info(self, scope: str, message: str) -> None:
        self.write("INFO", scope, message)

+    def notice(self, scope: str, message: str) -> None:
+        """Etwas ist passiert, und es ist in Ordnung -- aber es gehoert gesehen.
+
+        Zwischen "laeuft" und "stimmt etwas nicht" fehlte eine Stufe. Ein
+        Geraet, das neu gestartet wird, ist kein Fehler; es einfach als INFO
+        zwischen zweihundert Erreichbarkeitsmeldungen zu stellen heisst aber,
+        dass es niemand findet.
+        """
+        self.write("HINWEIS", scope, message)
+
    def warning(self, scope: str, message: str) -> None:
        self.write("WARNUNG", scope, message)

@@ -278,6 +288,39 @@ METHOD_LABELS = {
    METHOD_RPC: "Neustart über RPC",
 }

+#: Wer den Neustart ausgeloest hat -- in Worten statt in Schluesseln.
+#:
+#: Die Schluessel stehen so in der Datenbank und bleiben dort; eine Spalte
+#: umzuschreiben, um eine Anzeige zu verbessern, waere der falsche Weg. Die
+#: Uebersetzung gehoert an genau eine Stelle, sonst heisst derselbe Vorgang im
+#: Protokoll "auto" und auf der Seite "automatisch".
+TRIGGER_LABELS = {
+    "auto": "automatisch",
+    "manuell": "manuell",
+    "maintenance": "aus der Wartung",
+}
+
+
+def trigger_label(trigger: str) -> str:
+    """Der Ausloeser als Wort -- unbekannte Schluessel bleiben, wie sie sind."""
+    return TRIGGER_LABELS.get(str(trigger or ""), str(trigger or "unbekannt"))
+
+
+def _geraet_kurz(conn: sqlite3.Connection, device_id: int) -> str:
+    """``Name (IP)`` fuer das laufende Protokoll.
+
+    Die Neustart-Funktionen bekommen nur eine Kennung; im Protokoll steht aber
+    eine Zeile, die ein Mensch liest -- und "Geraet 17 wird neu gestartet"
+    hilft niemandem.
+    """
+    row = conn.execute("SELECT name, ip FROM devices WHERE id=?", (int(device_id),)).fetchone()
+    if row is None:
+        return f"Gerät {device_id}"
+    name = str(row["name"] or "").strip() or f"Gerät {device_id}"
+    ip = str(row["ip"] or "").strip()
+    return f"{name} ({ip})" if ip else name
+
+
 #: Zustand zwischen ausgeloestem Neustart und Rueckkehr.
 #:
 #: Ohne ihn blieb die Kachel auf "online" stehen: der Zustand wechselt erst
@@ -303,6 +346,7 @@ def record_restart(
    duration_ms: int,
    detail: str,
    method: str = METHOD_POE,
+    live: Any = None,
 ) -> None:
    """Schreibt einen Neustart ins Protokoll -- unabhaengig davon, wie er lief.

@@ -311,6 +355,12 @@ def record_restart(
    nur in ``method``. Vorher gab es nur die PoE-Haelfte, und ein per Wartung
    neu gestartetes Geraet tauchte in der Neustart-Historie ueberhaupt nicht
    auf.
+
+    Mit ``live`` steht das Ergebnis auch im laufenden Protokoll. Diese
+    Funktion ist der Trichter, durch den **jeder** Neustart laeuft -- PoE
+    automatisch wie von Hand, SSH und RPC aus der Wartung. Die Zeile hier zu
+    schreiben statt bei jeder Quelle einzeln ist der Unterschied zwischen
+    "alle Wege sind abgedeckt" und "alle Wege, an die jemand gedacht hat".
    """
    conn.execute(
        "INSERT INTO restart_events "
@@ -318,6 +368,17 @@ def record_restart(
        "VALUES (?,?,?,?,?,?,?,?,?)",
        (device_id, _now(), trigger, actor, action, result, duration_ms, detail[:8000], method),
    )
+    if live is not None:
+        wer = _geraet_kurz(conn, device_id)
+        weg = METHOD_LABELS.get(method, method)
+        if result == "ok":
+            live.info("neustart", f"{wer}: Neustart über {weg} erfolgreich")
+        elif result == "skipped":
+            # Warnstufe: ein Geraet, das haette neu gestartet werden sollen und
+            # es nicht wurde, ist kein Hinweis am Rande.
+            live.warning("neustart", f"{wer}: Neustart nicht ausgeführt – {detail}")
+        else:
+            live.error("neustart", f"{wer}: Neustart fehlgeschlagen – {detail}")
    if result == "ok":
        # Hier faellt nur noch der Zaehler und der Zeitstempel an. Den Zustand
        # setzt ``mark_restarting`` schon beim Ausloesen -- dieses Ergebnis
@@ -330,7 +391,14 @@ def record_restart(
        )


-def mark_restarting(conn: sqlite3.Connection, device_id: int) -> None:
+def mark_restarting(
+    conn: sqlite3.Connection,
+    device_id: int,
+    *,
+    live: Any = None,
+    trigger: str = "",
+    method: str = METHOD_POE,
+) -> None:
    """Setzt den Zustand auf "startet neu" -- beim **Ausloesen**, nicht am Ende.

    Ein Neustart ueber SSH oder RPC laeuft als Auftrag: Kommando schicken, dann
@@ -342,6 +410,12 @@ def mark_restarting(conn: sqlite3.Connection, device_id: int) -> None:
    Absicht. Und ohne ``last_restart_at``: das Kulanzfenster laeuft ab dem
    Zeitpunkt, an dem der Neustart tatsaechlich ausgeloest wurde
    (``record_restart``).
+
+    Mit ``live`` geht der Beginn ins laufende Protokoll -- als Hinweis, nicht
+    als Warnung: ein Neustart ist kein Stoerfall, aber er erklaert die Luecke,
+    die gleich in der Erreichbarkeit steht. Dass die Zeile hier entsteht und
+    nicht bei den Aufrufern, ist Absicht: dies ist der Punkt, an dem ein
+    Neustart **ausgeloest** wird, gleich von welcher Quelle.
    """
    conn.execute(
        """
@@ -355,6 +429,12 @@ def mark_restarting(conn: sqlite3.Connection, device_id: int) -> None:
        """,
        (device_id, STATE_RESTARTING, _now(), _now()),
    )
+    if live is not None:
+        weg = METHOD_LABELS.get(method, method)
+        woher = f" ({trigger_label(trigger)})" if trigger else ""
+        live.notice(
+            "neustart", f"{_geraet_kurz(conn, device_id)} wird neu gestartet – {weg}{woher}"
+        )


 # --------------------------------------------------------------------------- #
@@ -402,7 +482,9 @@ def restart_device_poe(
    # wie fuer den automatischen Neustart, denn beide laufen hier durch.
    if port and switch_ip:
        with write():
-            mark_restarting(conn, int(device["id"]))
+            mark_restarting(
+                conn, int(device["id"]), live=live, trigger=trigger, method=METHOD_POE
+            )

    if not port or not switch_ip:
        message = (
@@ -418,6 +500,7 @@ def restart_device_poe(
            actor=actor,
            duration_ms=0,
            detail=message,
+            live=live,
        )
        return {"ok": False, "message": message, "transcript": ""}

@@ -462,9 +545,8 @@ def restart_device_poe(
            actor=actor,
            duration_ms=duration,
            detail=str(exc),
+            live=live,
        )
-        if live:
-            live.error("poe", f"{name}: {exc}")
        return {"ok": False, "message": str(exc), "transcript": ""}

    duration = int((time.monotonic() - started) * 1000)
@@ -478,12 +560,8 @@ def restart_device_poe(
        actor=actor,
        duration_ms=duration,
        detail=(outcome.error or "; ".join(outcome.steps))[:8000],
+        live=live,
    )
-    if live:
-        if outcome.ok:
-            live.info("poe", f"{name}: PoE-Neustart auf {device.get('switch_hostname')} {port} erfolgreich")
-        else:
-            live.error("poe", f"{name}: PoE-Neustart fehlgeschlagen -- {outcome.error}")
    return {
        "ok": outcome.ok,
        "message": outcome.error or "PoE-Neustart durchgeführt.",
@@ -641,9 +719,21 @@ def run_sweep(
        name = str(device["name"])
        if not license_allows_auto_restart:
            report.skipped_unlicensed += 1
-            live.warning(
-                "poe",
-                f"{name}: automatischer PoE-Neustart übersprungen – keine gültige Lizenz.",
+            # Als Zeile in der Neustart-Historie, nicht nur als Protokollsatz:
+            # wer auf der Seite "Neustarts" nachsieht, warum ein Geraet nicht
+            # zurueckkam, soll dort auch lesen, dass TESM es versucht haette.
+            # Ein leerer Verlauf sieht sonst aus wie "es war nichts noetig".
+            with database.session() as conn, database.transaction(conn):
+                record_restart(
+                    conn,
+                    device_id=int(device["id"]),
+                    action="cycle",
+                    result="skipped",
+                    trigger="auto",
+                    actor="system",
+                    duration_ms=0,
+                    detail="keine gültige Lizenz für den automatischen PoE-Neustart",
+                    live=live,
                )
            continue
        report.restarts_triggered += 1
@@ -377,6 +377,10 @@
        <div class="card__title">{{ icon('clock', size=17) }} Leases</div>
        <div class="card__sub">
          Direkt aus {{ lease_file }} gelesen &ndash; je Adresse gilt der letzte Eintrag.
+          {% if current_user.has('dhcp_lease_adopt.read') and current_user.has('devices.create') %}
+            Eine <strong>dynamische</strong> Lease lässt sich als Client übernehmen; sie bekommt
+            damit eine feste Adresse und wird überwacht.
+          {% endif %}
        </div>
      </div>
    </div>
@@ -394,7 +398,7 @@
      <div class="table-wrap" style="max-height:420px;overflow:auto">
        <table class="table table--compact">
          <thead><tr><th>IP</th><th>MAC</th><th>Hostname</th><th>Art</th><th>Zustand</th>
-                     <th>Läuft ab</th></tr></thead>
+                     <th>Läuft ab</th><th></th></tr></thead>
          <tbody>
            {% for lease in leases %}
              <tr>
@@ -413,6 +417,31 @@
                <td class="fs-sm">{{ lease.expires_text }}
                  <div class="fs-xs faint">{{ lease.remaining_text }}</div>
                </td>
+                <td class="nowrap">
+                  {# Übernehmen gibt es nur für dynamische Leases: was reserviert
+                     ist, gehört schon zu einem gepflegten Datensatz. Und nur,
+                     wenn beide Rechte stehen -- hier entsteht ein Client. #}
+                  {% if lease.address not in reserved_ips
+                        and current_user.has('dhcp_lease_adopt.read')
+                        and current_user.has('devices.create') %}
+                    {% if lease.mac in bekannte_macs %}
+                      <span class="faint fs-xs" title="Zu dieser MAC gibt es bereits einen Client">
+                        bereits Client
+                      </span>
+                    {% else %}
+                      <form method="post" action="{{ url_for('dhcp.adopt_lease') }}">
+                        <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">
+                        <input type="hidden" name="mac" value="{{ lease.mac }}">
+                        <button class="btn btn--sm btn--ghost" type="submit"
+                                data-confirm="{{ lease.hostname or lease.address }} als überwachten Client anlegen? Switch, Port und Zugangsdaten tragen Sie danach nach."
+                                data-confirm-title="Als Client übernehmen"
+                                data-confirm-ok="Übernehmen">
+                          {{ icon('plus', size=14) }} Als Client
+                        </button>
+                      </form>
+                    {% endif %}
+                  {% endif %}
+                </td>
              </tr>
            {% endfor %}
          </tbody>
@@ -6,7 +6,8 @@
 {% block content %}
 {{ alert('Jeder Neustart wird mit Methode, Ergebnis, Dauer und Auslöser festgehalten -- automatisch
 wie manuell, über den PoE-Port des Switches ebenso wie per Neustart-Befehl aus der Wartung.
-Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}
+Auch ein Neustart, den die Überwachung auslösen wollte und nicht durfte, steht hier:
+als "übersprungen" mit dem Grund. Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}

 <section class="card">
  <div class="card__header">
@@ -32,7 +33,7 @@ Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}
      </tr></thead>
      <tbody>
        {% for row in rows %}
-          <tr data-filter-text="{{ row.device_name }} {{ row.result }} {{ row.actor }} {{ method_labels.get(row.method, row.method) }} {{ row.detail }}">
+          <tr data-filter-text="{{ row.device_name }} {{ row.result }} {{ row.actor }} {{ method_labels.get(row.method, row.method) }} {{ trigger_labels.get(row.trigger, row.trigger) }} {{ row.detail }}">
            <td class="fs-sm nowrap" data-sort-value="{{ row.ts }}">{{ row.ts | dt }}</td>
            <td class="fw-600 fs-sm">{{ row.device_name or '&ndash;' | safe }}</td>
            <td class="fs-sm">
@@ -41,10 +42,15 @@ Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}
                 jahrelang als PoE ausgegeben. #}
              {% if row.method == 'ssh' %}{{ pill('SSH', 'info') }}
              {% elif row.method == 'rpc' %}{{ pill('RPC', 'accent') }}
-              {% elif row.method == 'pö' %}{{ pill('PoE-Port', '') }}
+              {# 'poe', nicht 'pö'. Der Umlaut stand hier durch eine
+                 Ersetzung, die "oe" fuer eine Umschrift hielt -- und traf den
+                 haeufigsten Fall von allen: jeder automatische Neustart laeuft
+                 ueber den PoE-Port. Sie standen damit als orangefarbenes
+                 "poe" da, wo "PoE-Port" stehen sollte. #}
+              {% elif row.method == 'poe' %}{{ pill('PoE-Port', '') }}
              {% else %}{{ pill(row.method or 'unbekannt', 'warning') }}{% endif %}
            </td>
-            <td class="fs-sm">{{ row.trigger }}</td>
+            <td class="fs-sm">{{ trigger_labels.get(row.trigger, row.trigger) }}</td>
            <td class="fs-sm">{{ row.actor }}</td>
            <td>
              {% if row.result == 'ok' %}{{ pill('erfolgreich', 'online') }}
@@ -45,12 +45,22 @@ brauchen dafür weder SSH noch einen Host-Schlüssel, sondern die offene Datei-
 Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Port.',
 'info') }}

-<form method="post" id="maintenance-form" action="{{ url_for('maintenance.start_update') }}">
+{# ``stack``: Massenbefehl und Geräteauswahl sind zwei Bereiche und sollen auch
+   so aussehen. Ohne das stossen die beiden Karten aneinander. #}
+<form method="post" id="maintenance-form" class="stack"
+      action="{{ url_for('maintenance.start_update') }}">
  <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">

  {% if current_user.has('servicing_command.read') %}
+    {# Zugeklappt beim Laden: der Massenbefehl ist das seltenere Werkzeug, die
+       Geräteliste darunter das tägliche. Aufgeklappt schob er sie aus dem
+       Bild. #}
    <section class="card">
      <div class="card__header">
+        <button class="btn btn--ghost btn--sm" type="button" data-befehl-schalter
+                aria-expanded="false" title="Massenbefehl ein- und ausklappen">
+          {{ icon('chevron-right', size=14) }}
+        </button>
        <div class="flex-1">
          <div class="card__title">{{ icon('terminal', size=17) }} Massenbefehl</div>
          <div class="card__sub">
@@ -62,7 +72,7 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
          </div>
        </div>
      </div>
-      <div class="card__body stack">
+      <div class="card__body stack" data-befehl-feld hidden>
        <label class="field">
          <span class="field__label">Vorlage</span>
          <select class="select" id="befehlsvorlage">
@@ -95,6 +105,9 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
        <input type="checkbox" id="select-all">
        <span>Alle auswählen</span>
      </label>
+      <button class="btn btn--sm btn--ghost" type="button" data-alle-einklappen>
+        {{ icon('chevron-up', size=14) }} Alle einklappen
+      </button>
      <span class="table-toolbar__spacer"></span>
      {% if current_user.has('servicing_command.execute') %}
        <button class="btn btn--sm" type="submit"
@@ -129,6 +142,7 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
            <th class="sortable">Gerät</th>
            <th class="sortable">IP</th>
            <th class="sortable">Zustand</th>
+            <th class="sortable">Auftrag</th>
            <th class="sortable">Zugangsdaten</th>
            <th class="sortable">Host-Schlüssel</th>
            <th></th>
@@ -162,6 +176,19 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
                {% elif device.state == 'offline' %}{{ pill('offline', 'offline') }}
                {% else %}{{ pill('unbekannt', 'warning') }}{% endif %}
              </td>
+              {# Wie weit ist der Auftrag dieses Geräts? Ohne diese Spalte
+                 blieb nur die Auftragsliste weiter unten -- und dort steht
+                 nicht, welche Zeile zu welchem Gerät gehört, wenn vierzig
+                 Aufträge in derselben Sekunde starten. #}
+              <td data-auftragslage="{{ device.name }}">
+                {% set lage = auftragslage.get(device.name) %}
+                {% if not lage %}<span class="faint fs-xs">–</span>
+                {% elif lage.state == 'running' %}{{ pill('läuft', 'info') }}
+                {% elif lage.state == 'pending' %}{{ pill('wartet', '') }}
+                {% elif lage.state == 'succeeded' %}{{ pill('fertig', 'online') }}
+                {% elif lage.state == 'failed' %}{{ pill('Fehler', 'danger') }}
+                {% else %}{{ pill('unklar', 'warning') }}{% endif %}
+              </td>
              <td class="fs-sm">
                {{ device.credential_name }}
                <div class="fs-xs faint">{{ category_labels.get(device.category, device.category) }}</div>
@@ -190,7 +217,7 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
              </td>
            </tr>
            <tr data-ausgabe-zeile="{{ device.name }}" hidden>
-              <td colspan="7" class="p-0">
+              <td colspan="8" class="p-0">
                <pre class="job-output" data-ausgabe="{{ device.name }}">Noch keine Ausgabe.</pre>
              </td>
            </tr>
@@ -289,28 +316,59 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
  // lief -- das verwarf jede Auswahl, jeden Tastendruck im Befehlsfeld und
  // sprang nach oben. Jetzt kommen nur die letzten Zeilen, und die Seite
  // bleibt stehen.
+  // Der Massenbefehl: zugeklappt geladen, per Kopfzeile aufgeklappt.
+  const befehlSchalter = document.querySelector("[data-befehl-schalter]");
+  const befehlFeld = document.querySelector("[data-befehl-feld]");
+  befehlSchalter?.addEventListener("click", () => {
+    const zu = befehlFeld.hidden;
+    befehlFeld.hidden = !zu;
+    befehlSchalter.setAttribute("aria-expanded", zu ? "true" : "false");
+    befehlSchalter.style.transform = zu ? "rotate(90deg)" : "";
+    if (zu) document.getElementById("befehl")?.focus();
+  });
+
  const schalter = Array.from(document.querySelectorAll("[data-ausgabe-schalter]"));
-  const offen = new Set();
+  // Wer von Hand zuklappt, will es zu haben. Ohne dieses Gedaechtnis riss die
+  // naechste Statusabfrage die Zeile wieder auf, weil dort noch Ausgabe stand
+  // -- zwei Sekunden spaeter, jedes Mal.
+  const zugeklappt = new Set();
+  // Beim ersten Fuellen ans Ende springen, danach nur, wenn man ohnehin unten
+  // steht. So steht nach dem Neuladen der Seite das Aktuelle im Bild und nicht
+  // der Anfang von vorgestern -- und wer hochscrollt, um etwas zu lesen, wird
+  // nicht wieder heruntergezogen.
+  const gefuellt = new Set();
+
+  function klappen(name, zu) {
+    const zeile = document.querySelector(`[data-ausgabe-zeile="${CSS.escape(name)}"]`);
+    if (!zeile) return;
+    zeile.hidden = zu;
+    if (zu) zugeklappt.add(name);
+    else zugeklappt.delete(name);
+  }
+
  schalter.forEach((knopf) => {
    knopf.addEventListener("click", () => {
      const name = knopf.dataset.ausgabeSchalter;
      const zeile = document.querySelector(`[data-ausgabe-zeile="${CSS.escape(name)}"]`);
-      if (!zeile) return;
-      zeile.hidden = !zeile.hidden;
-      if (zeile.hidden) offen.delete(name);
-      else offen.add(name);
+      if (zeile) klappen(name, !zeile.hidden);
    });
  });

+  document.querySelector("[data-alle-einklappen]")?.addEventListener("click", () => {
+    schalter.forEach((knopf) => klappen(knopf.dataset.ausgabeSchalter, true));
+  });
+
  function zeigen(name, text) {
    const feld = document.querySelector(`[data-ausgabe="${CSS.escape(name)}"]`);
    const zeile = document.querySelector(`[data-ausgabe-zeile="${CSS.escape(name)}"]`);
    if (!feld || !zeile) return;
+    const erstmals = !gefuellt.has(name);
    const unten = feld.scrollTop + feld.clientHeight >= feld.scrollHeight - 24;
    feld.textContent = text || "Noch keine Ausgabe.";
-    if (unten) feld.scrollTop = feld.scrollHeight;
+    if (text) gefuellt.add(name);
+    if (erstmals || unten) feld.scrollTop = feld.scrollHeight;
    // Was läuft, klappt von selbst auf -- wer zusieht, will nicht erst suchen.
-    if (text && zeile.hidden && !offen.has(name)) zeile.hidden = false;
+    if (text && zeile.hidden && !zugeklappt.has(name)) zeile.hidden = false;
  }

  // Zustand, Fortschritt und Meldung eines Auftrags nachziehen.
@@ -348,13 +406,41 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
    return true;
  }

+  // Dieselben fünf Zustände wie in der Auftragsliste -- hier aber neben dem
+  // Gerät, wo man sie sucht.
+  const LAGE = {
+    pending: ["wartet", ""],
+    running: ["läuft", "pill--info"],
+    succeeded: ["fertig", "pill--online"],
+    failed: ["Fehler", "pill--danger"],
+    unknown: ["unklar", "pill--warning"],
+  };
+
+  function lageZeigen(name, zustand) {
+    const zelle = document.querySelector(`[data-auftragslage="${CSS.escape(name)}"]`);
+    if (!zelle) return;
+    const [text, klasse] = LAGE[zustand] || LAGE.pending;
+    const vorhanden = zelle.querySelector(".pill");
+    if (vorhanden && vorhanden.textContent.trim() === text) return;
+    const pille = document.createElement("span");
+    pille.className = `pill ${klasse}`.trim();
+    pille.textContent = text;
+    zelle.replaceChildren(pille);
+  }
+
  let neueAuftraege = false;
  async function poll() {
    let weiter = 10000;
    try {
      const state = await window.tesm.api("{{ url_for('maintenance.status') }}", { auto: true });
      weiter = state.poll_ms || 10000;
+      // Der neueste Auftrag je Gerät gewinnt; die Liste kommt neueste zuerst.
+      const gesehen = new Set();
      state.jobs.forEach((job) => {
+        if (!gesehen.has(job.subject)) {
+          gesehen.add(job.subject);
+          lageZeigen(job.subject, job.state);
+        }
        if (job.output) zeigen(job.subject, job.output);
        // Ein Auftrag, der in der Tabelle noch gar nicht steht, ist neu --
        // dafür braucht es die Seite einmal frisch, aber erst, wenn nichts
@@ -113,7 +113,11 @@ class MonitorDaemon:
                time.sleep(min(1.0, remaining))
                remaining -= 1.0

-        live.info("monitor", "Überwachungsprozess beendet")
+        # Warnstufe, nicht INFO: dass die Ueberwachung *laeuft*, ist der
+        # Normalfall und darf gruen sein. Dass sie **steht**, ist der Zustand,
+        # in dem niemand mehr erfaehrt, dass ein Geraet weg ist -- und genau
+        # diese Zeile sucht man hinterher im Protokoll.
+        live.warning("monitor", "Überwachungsprozess beendet")
        return 0


@@ -418,9 +418,32 @@ info "Dateien abgeglichen (Instanzdaten unter data/ bleiben unangetastet)"

 # -- venv --------------------------------------------------------------------
 step "Python-Umgebung"
-if [[ ! -x "$ROOT/venv/bin/python3" ]]; then
+# Ein venv haengt an der **Minor-Fassung**, mit der er gebaut wurde: die Pakete
+# liegen unter lib/python3.X. Wechselt die Systemfassung -- ein Release-Upgrade
+# von Ubuntu bringt genau das, 24.04 hat 3.12 und 26.04 hat 3.14 --, dann ist
+# venv/bin/python3 weiter ausfuehrbar: der Verweis zeigt auf /usr/bin/python3,
+# also auf den **neuen** Interpreter. Der venv sieht heil aus und ist es nicht.
+# Er findet danach kein einziges Paket mehr, nicht einmal pip.
+#
+# Gemessen auf dem Testserver, mit verschobenem lib-Verzeichnis:
+#     [[ -x venv/bin/python3 ]]        -> wahr
+#     venv/bin/python3 -m pip --version -> "No module named pip"
+#
+# Die alte Pruefung fragte nur nach der Ausfuehrbarkeit. Sie haette den toten
+# venv behalten und waere eine Zeile spaeter an "python3 -m pip" gescheitert --
+# mitten in einer Aktualisierung, auf einem Server, dessen Dienste ohnehin
+# schon stehen. Gefragt wird deshalb, was gebraucht wird: laesst sich in
+# diesem venv pip benutzen?
+venv_traegt() {
+  [[ -x "$ROOT/venv/bin/python3" ]] || return 1
+  "$ROOT/venv/bin/python3" -c "import pip" >/dev/null 2>&1
+}
+if ! venv_traegt; then
+  # Ohne --clear: ein erneutes "venv" ergaenzt das fehlende lib-Verzeichnis und
+  # holt pip zurueck; die Abhaengigkeiten kommen gleich darunter ohnehin neu.
+  # Auch das ist gemessen und nicht angenommen.
  python3 -m venv "$ROOT/venv"
-  info "venv erzeugt"
+  info "Python-Umgebung aufgebaut ($(python3 -V 2>&1))"
 fi
 # Immer ueber "python3 -m pip" -- der pip-Shim im venv baeckt einen absoluten
 # Pfad in seinen Shebang, der nach einer Umbenennung des Verzeichnisses bricht.
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"

 [project]
 name = "tesm-core"
-version = "2.8.15"
+version = "2.8.17"
 description = "Gemeinsames Anwendungsgeruest (Auth, RBAC, Navigation, Design-System, Migrationen) fuer TESM und TESM-Lizenzserver"
 requires-python = ">=3.11"
 dependencies = [
@@ -42,6 +42,8 @@ def _config_from_settings(extension: Any, conn: Any) -> webserver.WebConfig:
        ],
    )
    return webserver.WebConfig(
+        # Die neue Schreibweise, sobald der Webserver sie kennt.
+        http2_directive=webserver.nginx_kann_http2(),
        app_key=extension.config.site_key,
        upstream=str(extension.registry.get("upstream", "127.0.0.1:5000")),
        static_root=str(
@@ -129,7 +129,7 @@ DIAGNOSTICS = Resource(

 LOGS_LIVE = Resource(
    key="logs_live",
-    label="Laufendes Protokoll",
+    label="Live-Protokoll",
    actions=(A.READ,),
 )

@@ -1133,6 +1133,16 @@
  }
  .log-view mark { background: var(--warning-soft); color: var(--warning); border-radius: 3px; }

+  /* Stufen im laufenden Protokoll. Die Zuordnung der Farbrollen ist Absicht:
+     --warning ist bernsteinfarben und traegt den HINWEIS, --danger ist rot und
+     traegt die WARNUNG. Wer das nach den Namen "aufraeumt", dreht die Bedeutung
+     um: ein Geraet, das nicht antwortet, waere dann orange und eines, das neu
+     startet, rot. */
+  .log-view__zeile--info { color: var(--success); }
+  .log-view__zeile--hinweis { color: var(--warning); }
+  .log-view__zeile--warnung { color: var(--danger); }
+  .log-view__zeile--fehler { color: var(--danger); font-weight: 600; }
+
  .kv { display: grid; grid-template-columns: auto 1fr; gap: var(--sp-2) var(--sp-4); font-size: var(--fs-base); }
  .kv dt { color: var(--text-faint); white-space: nowrap; }
  .kv dd { margin: 0; min-width: 0; overflow-wrap: anywhere; }
@@ -58,8 +58,14 @@ class WebConfig:
    #: ``listen ... ssl http2;`` und weisen die neue Direktive mit
    #: "unknown directive" ab -- der ganze Webserver startet dann nicht mehr.
    #: Auf POETEST (nginx 1.24) genau so passiert. Vorgabe ist deshalb die alte
-    #: Schreibweise: sie funktioniert ueberall und erzeugt auf neuen Versionen
-    #: nur eine Warnung.
+    #: Schreibweise: sie funktioniert ueberall.
+    #:
+    #: Wer die Konfiguration erzeugt, fragt vorher ``nginx_kann_http2()`` --
+    #: dann steht auf einem neuen Webserver auch die neue Schreibweise. Das ist
+    #: nicht nur Kosmetik gegen eine Warnung: nginx hat die alte Form als
+    #: veraltet erklaert, und was veraltet ist, faellt irgendwann weg. Ein
+    #: Release-Upgrade von Ubuntu ist genau der Moment, in dem so etwas
+    #: unbemerkt naeherrueckt (24.04 hat nginx 1.24, 26.04 hat 1.28).
    http2_directive: bool = False

    @property
@@ -89,6 +95,47 @@ class WebConfig:
        return "" if self.https_port == 443 else f":{self.https_port}"


+#: Ab dieser Fassung kennt nginx ``http2 on;``.
+HTTP2_DIREKTIVE_AB = (1, 25, 1)
+
+
+def fassung_aus_ausgabe(text: str) -> tuple[int, ...]:
+    """``nginx version: nginx/1.28.3 (Ubuntu)`` -> ``(1, 28, 3)``.
+
+    Getrennt vom Aufruf, damit sich die Entscheidung pruefen laesst, ohne
+    einen Webserver zu installieren. Was nicht ins Muster passt, ergibt ein
+    leeres Tupel -- und damit die Schreibweise, die ueberall funktioniert.
+    """
+    treffer = re.search(r"nginx/(\d+)\.(\d+)\.(\d+)", text or "")
+    return tuple(int(teil) for teil in treffer.groups()) if treffer else ()
+
+
+def nginx_version() -> tuple[int, ...]:
+    """Die Fassung des installierten nginx, sonst ein leeres Tupel.
+
+    ``nginx -v`` schreibt nach stderr und braucht keine Rechte. Faellt die
+    Antwort aus -- kein nginx, kein Ausfuehrungsrecht, fremdes Format --, gibt
+    es hier nichts zu raten.
+    """
+    import shutil
+    import subprocess
+
+    pfad = shutil.which("nginx") or "/usr/sbin/nginx"
+    try:
+        fertig = subprocess.run(
+            [pfad, "-v"], capture_output=True, text=True, timeout=5, check=False
+        )
+    except (OSError, subprocess.SubprocessError):
+        return ()
+    return fassung_aus_ausgabe(fertig.stderr + fertig.stdout)
+
+
+def nginx_kann_http2() -> bool:
+    """Versteht der installierte nginx ``http2 on;``?"""
+    fassung = nginx_version()
+    return bool(fassung) and fassung >= HTTP2_DIREKTIVE_AB
+
+
 def validate_domain(value: str) -> str:
    text = (value or "").strip().lower().rstrip(".")
    if not text:
@@ -1,5 +1,8 @@
 {% if lines %}
-<pre class="log-view" data-tail>{% for line in lines %}{{ line }}
+{# Jede Zeile in einer Huelle, damit die Stufe eine Farbe tragen kann. Der
+   Zeilenumbruch steht ausserhalb: im <pre> ist er der Umbruch selbst, und
+   eine Huelle mit display:block wuerde daraus zwei machen. #}
+<pre class="log-view" data-tail>{% for line in lines %}{% set z = line | protokollzeile %}<span class="log-view__zeile{% if z.stufe %} log-view__zeile--{{ z.stufe }}{% endif %}">{{ z.text }}</span>
 {% endfor %}</pre>
 {% else %}
 <div class="empty"><div class="empty__title">Keine Zeilen</div>
@@ -25,7 +25,7 @@
              <tr>
                <td><a href="{{ url_for('logs.history_file', name=entry.name) }}">{{ entry.name }}</a></td>
                <td class="numeric fs-sm">{{ entry.size | bytes }}</td>
-                <td class="fs-sm">{{ entry.modified | int | string }}</td>
+                <td class="fs-sm">{{ entry.modified | dt }}</td>
              </tr>
            {% endfor %}
          </tbody>
@@ -1,5 +1,5 @@
 {% extends "tesm_core/base.html" %}
-{% block page_title %}Laufendes Protokoll{% endblock %}
+{% block page_title %}Live-Protokoll{% endblock %}
 {% block page_sub %}{{ path }} &middot; letzte {{ line_count }} Zeilen{% endblock %}

 {% block topbar_extra %}
@@ -113,6 +113,14 @@ def format_datetime(value: Any, *, with_time: bool = True) -> str:
        return "-"
    if isinstance(value, datetime):
        moment = value
+    elif isinstance(value, (int, float)) and not isinstance(value, bool):
+        # Sekunden seit 1970, wie sie aus ``stat()`` kommen. Ohne diesen Zweig
+        # stand im Protokollverlauf die nackte Zahl (1788472810) in der Spalte
+        # "Geändert" -- fuer die Datei sichtbar, fuer den Menschen nutzlos.
+        try:
+            moment = datetime.fromtimestamp(float(value), timezone.utc)
+        except (OSError, OverflowError, ValueError):
+            return str(value)
    else:
        text = str(value).strip()
        if text.endswith("Z"):
@@ -351,6 +359,38 @@ def audit_detail(text: Any) -> Markup:
    teile.append(str(escape(roh[ende:])))
    return Markup("".join(teile))

+#: Stufen im laufenden Protokoll und ihre Farbrolle in der Oberflaeche.
+#:
+#: Die Zuordnung ist Absicht und keine Verwechslung: die Farbrolle "warning"
+#: ist bernsteinfarben und traegt hier den **Hinweis**, "danger" ist rot und
+#: traegt die **Warnung**. Ein Geraet, das nicht antwortet, ist rot; ein
+#: Geraet, das neu gestartet wird, ist orange; alles Gelungene ist gruen.
+PROTOKOLLSTUFEN = {
+    "INFO": "info",
+    "HINWEIS": "hinweis",
+    "WARNUNG": "warnung",
+    "FEHLER": "fehler",
+}
+
+#: ``2026-09-16 09:54:03  INFO     ping       HAP02 ist wieder erreichbar``
+_PROTOKOLLZEILE = re.compile(
+    r"^\d{4}-\d\d-\d\d[ T]\d\d:\d\d:\d\d\s+([A-ZÄÖÜ]+)\s"
+)
+
+
+def protokollzeile(zeile: str) -> dict[str, str]:
+    """Zerlegt eine Protokollzeile so weit, dass die Seite sie faerben kann.
+
+    Bewusst nur so weit: der Text bleibt, wie er ist -- eine Protokollansicht,
+    die ihre Zeilen umbaut, ist keine mehr. Gebraucht wird allein die Stufe.
+    Was nicht ins Muster passt (fremde Protokolle wie das von Kea), bekommt
+    keine Farbe statt einer geratenen.
+    """
+    treffer = _PROTOKOLLZEILE.match(str(zeile or ""))
+    stufe = PROTOKOLLSTUFEN.get(treffer.group(1), "") if treffer else ""
+    return {"text": str(zeile or ""), "stufe": stufe}
+
+
 def init_app(app: Flask) -> None:
    app.jinja_env.globals.update(
        icon=icon,
@@ -371,6 +411,7 @@ def init_app(app: Flask) -> None:
        enumerate=enumerate,
    )
    app.jinja_env.filters.update(
+        protokollzeile=protokollzeile,
        bytes=format_bytes,
        dt=format_datetime,
        date=format_date,
@@ -204,6 +204,8 @@ def _web_config() -> webserver.WebConfig:
        ],
    )
    return webserver.WebConfig(
+        # Die neue Schreibweise, sobald der Webserver sie kennt.
+        http2_directive=webserver.nginx_kann_http2(),
        app_key=extension.config.site_key,
        upstream=str(extension.registry.get("upstream", "127.0.0.1:5000")),
        static_root=str(extension.registry.get("static_root", extension.config.base_dir / "static")),
@@ -68,12 +68,17 @@ def live_fragment():
 def history():
    extension = core()
    rotated = []
-    for path in sorted(extension.config.log_dir.glob("*.log.*"), reverse=True):
+    for path in extension.config.log_dir.glob("*.log.*"):
        try:
            stat = path.stat()
        except OSError:
            continue
        rotated.append({"name": path.name, "size": stat.st_size, "modified": stat.st_mtime})
+    # Nach Alter, nicht nach Namen: ``sorted(..., reverse=True)`` ueber die
+    # Dateinamen stellte "live.log.9" vor "live.log.27", weil "9" hinter "2"
+    # kommt. Gefragt ist aber die juengste Kopie zuerst, und das steht im
+    # Zeitstempel.
+    rotated.sort(key=lambda eintrag: eintrag["modified"], reverse=True)
    return render_template(
        "tesm_core/logs_history.html",
        rotated=rotated,
Author	SHA1	Message	Date
alientim	80d9e30bd4	Version 2.8.29 / Lizenzserver 2.8.5: Release-Upgrade von Ubuntu bricht den venv nicht mehr	2026-09-16 17:44:32 +02:00
alientim	bde2df2b44	Version 2.8.28: dynamische Lease als Client uebernehmen	2026-09-16 12:28:02 +02:00
alientim	76a73017db	Version 2.8.27: Live-Protokoll mit Stufen, Auftraege fallen nicht mehr heraus	2026-09-16 11:32:00 +02:00