Backend als Windows-Dienst registrierbar (SCM, wie Mail-Client)

Das Backend kann jetzt — analog zum Mail-Client — als Windows-Dienst laufen.

- main() refaktoriert: App-Logik in run_app(shutdown, service_mode); eigene
  tokio-Runtime statt #[tokio::main]. Windows startet zuerst den SCM-Dispatcher,
  fällt bei interaktivem Start auf Konsolenmodus zurück (--console erzwingt ihn).
- src/service.rs (windows-only): SCM-Integration via windows-service-Crate,
  Stop/Shutdown-Handler, Running/Stopped-Status. Setzt das Arbeitsverzeichnis
  aufs EXE-Verzeichnis (Dienst startet sonst in System32), damit config.toml/
  data/logs daneben liegen. Fallback-Log bei Boot-Fehler.
- Graceful Shutdown: GSD-Lizenz-Freigabe in den Serve-Wrapper gezogen (greift
  in beiden Modi); Stop-Trigger ist das übergebene shutdown-Future.
- Logging: Konsolenmodus → stderr (wie bisher); Dienst-Modus → rollende
  Tagesdatei (tracing-appender) unter [logging] dir (Default logs/).
- install-service.ps1 / uninstall-service.ps1 (Dienst "Holzleitner Backend").
- README: Windows-Dienst-Abschnitt; .gitignore: /logs + Fatal-Log.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/api/src/service.rs

@@ -0,0 +1,139 @@
+//! Windows-Dienst-Integration (Service Control Manager). Nur unter Windows
+//! kompiliert (`#[cfg(windows)] mod service` in `main.rs`).
+//!
+//! Ablauf: `run()` übergibt den Prozess an den SCM. Der SCM ruft `service_main`
+//! in einem eigenen Thread; dort registrieren wir einen Control-Handler
+//! (Stop/Shutdown), melden „Running", starten eine eigene tokio-Runtime und
+//! lassen `crate::run_app` laufen, bis der Handler ein Stop-Signal schickt.
+//!
+//! Das Arbeitsverzeichnis wird auf das EXE-Verzeichnis gesetzt, weil ein Dienst
+//! sonst in `C:\Windows\System32` startet — damit landen `config.toml`,
+//! `data/` und `logs/` neben der EXE (so wie das Install-Skript es erwartet).
+
+use std::ffi::OsString;
+use std::path::Path;
+use std::sync::mpsc;
+use std::time::Duration;
+
+use windows_service::service::{
+    ServiceControl, ServiceControlAccept, ServiceExitCode, ServiceState, ServiceStatus, ServiceType,
+};
+use windows_service::service_control_handler::{self, ServiceControlHandlerResult};
+use windows_service::{define_windows_service, service_dispatcher};
+
+/// Interner Dienst-Name (Schlüssel). **Muss** mit dem `-ServiceName` im
+/// Install-Skript (`install-service.ps1`) übereinstimmen. Der Anzeigename
+/// „Holzleitner Backend" wird separat beim Registrieren gesetzt.
+const SERVICE_NAME: &str = "HolzleitnerBackend";
+const SERVICE_TYPE: ServiceType = ServiceType::OWN_PROCESS;
+
+define_windows_service!(ffi_service_main, service_main);
+
+/// Übergibt den Prozess an den SCM. Gibt `Err` zurück, wenn der Prozess NICHT
+/// vom SCM gestartet wurde (interaktiver Start) — der Aufrufer fällt dann in
+/// den Konsolenmodus zurück.
+pub fn run() -> windows_service::Result<()> {
+    service_dispatcher::start(SERVICE_NAME, ffi_service_main)
+}
+
+fn service_main(_args: Vec<OsString>) {
+    let _ = run_service();
+}
+
+fn run_service() -> windows_service::Result<()> {
+    // Arbeitsverzeichnis aufs EXE-Verzeichnis setzen (Dienst startet sonst in
+    // System32) — damit config.toml/data/logs neben der EXE aufgelöst werden.
+    if let Some(dir) = std::env::current_exe()
+        .ok()
+        .and_then(|p| p.parent().map(Path::to_path_buf))
+    {
+        let _ = std::env::set_current_dir(&dir);
+    }
+
+    // Kanal: Control-Handler -> Loop. Stop/Shutdown sendet ein () hinein.
+    let (shutdown_tx, shutdown_rx) = mpsc::channel::<()>();
+
+    let handler = move |control| -> ServiceControlHandlerResult {
+        match control {
+            ServiceControl::Stop | ServiceControl::Shutdown => {
+                let _ = shutdown_tx.send(());
+                ServiceControlHandlerResult::NoError
+            }
+            ServiceControl::Interrogate => ServiceControlHandlerResult::NoError,
+            _ => ServiceControlHandlerResult::NotImplemented,
+        }
+    };
+
+    let status_handle = service_control_handler::register(SERVICE_NAME, handler)?;
+
+    // „Running" melden (akzeptiert Stop + System-Shutdown).
+    status_handle.set_service_status(ServiceStatus {
+        service_type: SERVICE_TYPE,
+        current_state: ServiceState::Running,
+        controls_accepted: ServiceControlAccept::STOP | ServiceControlAccept::SHUTDOWN,
+        exit_code: ServiceExitCode::Win32(0),
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    })?;
+
+    // Eigene tokio-Runtime im Dienst-Thread (kein #[tokio::main]).
+    let rt = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .expect("tokio runtime");
+    let result = rt.block_on(async move {
+        // mpsc::recv ist blockierend → in spawn_blocking auslagern und als
+        // Future an run_app übergeben.
+        let shutdown = async move {
+            let _ = tokio::task::spawn_blocking(move || {
+                let _ = shutdown_rx.recv();
+            })
+            .await;
+        };
+        crate::run_app(shutdown, true).await
+    });
+
+    // Boot-/Laufzeitfehler: vor der Logger-Initialisierung gibt es im Dienst
+    // keine Spur — daher in eine Fallback-Datei neben die EXE schreiben.
+    let exit_code = match result {
+        Ok(()) => ServiceExitCode::Win32(0),
+        Err(e) => {
+            fallback_log(&format!("run_app fehlgeschlagen: {e:#}"));
+            ServiceExitCode::Win32(1)
+        }
+    };
+
+    // „Stopped" melden.
+    status_handle.set_service_status(ServiceStatus {
+        service_type: SERVICE_TYPE,
+        current_state: ServiceState::Stopped,
+        controls_accepted: ServiceControlAccept::empty(),
+        exit_code,
+        checkpoint: 0,
+        wait_hint: Duration::default(),
+        process_id: None,
+    })?;
+
+    Ok(())
+}
+
+/// Notfall-Logging, wenn der reguläre Logger (noch) nicht steht — schreibt nach
+/// `<exe-dir>\holzleitner-backend-fatal.log`. Im Dienst-Modus die einzige Spur,
+/// falls schon das Laden von `config.toml` scheitert.
+fn fallback_log(msg: &str) {
+    let file = crate::exe_dir().join("holzleitner-backend-fatal.log");
+    if let Ok(mut f) = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(&file)
+    {
+        use std::io::Write;
+        let _ = writeln!(
+            f,
+            "[{}] {}",
+            chrono::Local::now().format("%Y-%m-%d %H:%M:%S"),
+            msg
+        );
+    }
+}