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>
This commit is contained in:
Dennis Nemec
@ -1,8 +1,13 @@
|
||||
//! Holzleitner-API — HTTP-Layer und Composition Root.
|
||||
//!
|
||||
//! Bootstrap-Reihenfolge:
|
||||
//! Läuft entweder als **Windows-Dienst** (vom SCM gestartet) oder im
|
||||
//! **Konsolenmodus** (interaktiv / Linux / Mac). Die eigentliche App steckt
|
||||
//! in [`run_app`], die ein `shutdown`-Future als Stop-Trigger bekommt
|
||||
//! (Ctrl-C/SIGTERM im Konsolenmodus, SCM-Stop im Dienst).
|
||||
//!
|
||||
//! Bootstrap-Reihenfolge (in [`run_app`]):
|
||||
//! 1. Konfiguration aus `config.toml` laden (liefert u. a. den Log-Filter)
|
||||
//! 2. Tracing/Logging initialisieren
|
||||
//! 2. Tracing/Logging initialisieren (Konsole → stderr, Dienst → Datei)
|
||||
//! 3. Postgres-Pool aufbauen und Migrations ausführen
|
||||
//! 4. Keycloak-AuthService instanziieren
|
||||
//! 5. Use Cases zusammenstellen und in `AppState` packen
|
||||
@ -14,9 +19,12 @@ mod extractors;
|
||||
mod middleware;
|
||||
mod openapi;
|
||||
mod routes;
|
||||
#[cfg(windows)]
|
||||
mod service;
|
||||
mod state;
|
||||
|
||||
use std::net::SocketAddr;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
@ -64,27 +72,117 @@ use crate::middleware::{admin_api_key_middleware, jwt_middleware};
|
||||
use crate::openapi::ApiDoc;
|
||||
use crate::state::AppState;
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
// Config ZUERST laden — der Log-Filter steht jetzt in `config.toml`
|
||||
/// Verzeichnis der laufenden EXE. Wichtig im Dienst-Modus: ein Windows-Dienst
|
||||
/// startet mit Arbeitsverzeichnis `C:\Windows\System32`; damit `config.toml`,
|
||||
/// `data/` und `logs/` neben der EXE liegen, setzt der Dienst sein CWD auf
|
||||
/// dieses Verzeichnis (siehe `service::run`). Nur vom Windows-Dienst-Modul
|
||||
/// genutzt — auf anderen Plattformen daher als dead-code erlaubt.
|
||||
#[cfg_attr(not(windows), allow(dead_code))]
|
||||
pub(crate) fn exe_dir() -> PathBuf {
|
||||
std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|p| p.parent().map(|d| d.to_path_buf()))
|
||||
.unwrap_or_else(|| PathBuf::from("."))
|
||||
}
|
||||
|
||||
fn main() -> anyhow::Result<()> {
|
||||
// Unter Windows: standardmäßig versuchen, als Dienst zu starten. Wird die
|
||||
// EXE interaktiv gestartet (Konsole/Doppelklick), scheitert der
|
||||
// SCM-Dispatcher (nicht vom SCM gestartet) → Konsolenmodus. `--console`
|
||||
// erzwingt den Konsolenmodus direkt.
|
||||
#[cfg(windows)]
|
||||
{
|
||||
let console = std::env::args().any(|a| a == "--console" || a == "-c");
|
||||
if !console {
|
||||
match service::run() {
|
||||
Ok(()) => return Ok(()), // lief als Dienst, sauber beendet
|
||||
Err(_e) => { /* interaktiv gestartet → Konsole */ }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
run_console()
|
||||
}
|
||||
|
||||
/// Konsolenmodus: eigene tokio-Runtime, Stop via Ctrl-C/SIGTERM. Logs → stderr.
|
||||
fn run_console() -> anyhow::Result<()> {
|
||||
let rt = tokio::runtime::Builder::new_multi_thread()
|
||||
.enable_all()
|
||||
.build()
|
||||
.context("tokio runtime")?;
|
||||
rt.block_on(run_app(console_shutdown(), false))
|
||||
}
|
||||
|
||||
/// Stop-Signal für den Konsolenmodus: Ctrl-C oder (auf Unix) SIGTERM.
|
||||
async fn console_shutdown() {
|
||||
let ctrl_c = async {
|
||||
tokio::signal::ctrl_c()
|
||||
.await
|
||||
.expect("Ctrl-C-Handler konnte nicht installiert werden");
|
||||
};
|
||||
|
||||
#[cfg(unix)]
|
||||
let terminate = async {
|
||||
tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
|
||||
.expect("SIGTERM-Handler konnte nicht installiert werden")
|
||||
.recv()
|
||||
.await;
|
||||
};
|
||||
#[cfg(not(unix))]
|
||||
let terminate = std::future::pending::<()>();
|
||||
|
||||
tokio::select! {
|
||||
_ = ctrl_c => {},
|
||||
_ = terminate => {},
|
||||
}
|
||||
}
|
||||
|
||||
/// Die eigentliche App. `shutdown` ist der Stop-Trigger (Ctrl-C im Konsolen-,
|
||||
/// SCM-Stop im Dienst-Modus); `service_mode` steuert das Log-Ziel
|
||||
/// (Konsole → stderr, Dienst → rollende Tagesdatei in `[logging] dir`).
|
||||
///
|
||||
/// Gibt `Err` zurück, wenn der Bootstrap fehlschlägt — im Dienst-Modus fängt
|
||||
/// der Aufrufer (`service::run_service`) das ab und schreibt ein Fallback-Log,
|
||||
/// weil ein Boot-Fehler vor der Logger-Initialisierung sonst spurlos wäre.
|
||||
pub(crate) async fn run_app(
|
||||
shutdown: impl std::future::Future<Output = ()> + Send + 'static,
|
||||
service_mode: bool,
|
||||
) -> anyhow::Result<()> {
|
||||
// Config ZUERST laden — der Log-Filter steht in `config.toml`
|
||||
// (`[logging] filter`), also brauchen wir die Config, bevor der
|
||||
// Subscriber initialisiert wird. Fehler hier werden von anyhow auch
|
||||
// ohne aktiven Subscriber sichtbar (stderr).
|
||||
// Subscriber initialisiert wird.
|
||||
let cfg = config::load().context("config laden fehlgeschlagen")?;
|
||||
|
||||
tracing_subscriber::fmt()
|
||||
// Auf stderr loggen statt stdout: stderr ist unbuffered und erscheint
|
||||
// damit sofort — auch wenn die Ausgabe in eine Datei/Pipe/ein
|
||||
// IDE-Terminal läuft (stdout wäre dort blockgepuffert → Logs würden
|
||||
// erst verspätet/gar nicht sichtbar).
|
||||
.with_writer(std::io::stderr)
|
||||
.with_env_filter(
|
||||
// `RUST_LOG`-Env hat Vorrang (Ad-hoc-Debugging ohne Datei-Edit),
|
||||
// sonst der Filter aus `config.toml` (`[logging] filter`).
|
||||
tracing_subscriber::EnvFilter::try_from_default_env()
|
||||
.unwrap_or_else(|_| cfg.logging.filter.clone().into()),
|
||||
)
|
||||
.init();
|
||||
// `RUST_LOG`-Env hat Vorrang (Ad-hoc-Debugging ohne Datei-Edit), sonst der
|
||||
// Filter aus `config.toml`.
|
||||
let env_filter = tracing_subscriber::EnvFilter::try_from_default_env()
|
||||
.unwrap_or_else(|_| cfg.logging.filter.clone().into());
|
||||
|
||||
// Hält den non-blocking-Writer am Leben (flush beim Drop). Nur im
|
||||
// Dienst-Modus belegt; im Konsolenmodus `None` (stderr braucht keinen Guard).
|
||||
let _log_guard: Option<tracing_appender::non_blocking::WorkerGuard>;
|
||||
|
||||
if service_mode {
|
||||
// Dienst hat keine Konsole → in eine rollende Tagesdatei loggen, damit
|
||||
// die Logs nicht verloren gehen. Verzeichnis relativ zum CWD (= EXE-Dir,
|
||||
// vom Dienst gesetzt) bzw. absolut, falls so konfiguriert.
|
||||
let appender = tracing_appender::rolling::daily(&cfg.logging.dir, "holzleitner-backend.log");
|
||||
let (writer, guard) = tracing_appender::non_blocking(appender);
|
||||
_log_guard = Some(guard);
|
||||
tracing_subscriber::fmt()
|
||||
.with_writer(writer)
|
||||
.with_ansi(false) // keine Farbcodes in der Logdatei
|
||||
.with_env_filter(env_filter)
|
||||
.init();
|
||||
} else {
|
||||
// Konsole: stderr ist unbuffered und erscheint sofort — auch wenn die
|
||||
// Ausgabe in eine Datei/Pipe/ein IDE-Terminal läuft.
|
||||
_log_guard = None;
|
||||
tracing_subscriber::fmt()
|
||||
.with_writer(std::io::stderr)
|
||||
.with_env_filter(env_filter)
|
||||
.init();
|
||||
}
|
||||
|
||||
tracing::info!("starting up");
|
||||
// Vollständige (secret-maskierte) Konfig-Übersicht beim Start — damit
|
||||
@ -494,38 +592,17 @@ async fn main() -> anyhow::Result<()> {
|
||||
let listener = tokio::net::TcpListener::bind(addr).await?;
|
||||
tracing::info!("server läuft auf http://{}", addr);
|
||||
|
||||
// Graceful Shutdown: bei Ctrl-C / SIGTERM die GSD-Lizenz aktiv freigeben,
|
||||
// damit der Seat nicht bis zum Session-Ablauf geblockt bleibt.
|
||||
// Graceful Shutdown: auf den `shutdown`-Trigger warten (Ctrl-C/SIGTERM im
|
||||
// Konsolen-, SCM-Stop im Dienst-Modus), dann die GSD-Lizenz aktiv
|
||||
// freigeben, damit der Seat nicht bis zum Session-Ablauf geblockt bleibt.
|
||||
let graceful = async move {
|
||||
shutdown.await;
|
||||
tracing::info!("shutdown signal empfangen — gebe GSD-Lizenz frei");
|
||||
gsd_service.release_license().await;
|
||||
};
|
||||
axum::serve(listener, app)
|
||||
.with_graceful_shutdown(shutdown_signal(gsd_service))
|
||||
.with_graceful_shutdown(graceful)
|
||||
.await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Wartet auf Ctrl-C bzw. SIGTERM und gibt davor die GSD-Lizenz frei.
|
||||
async fn shutdown_signal(gsd_service: Arc<GsdService>) {
|
||||
let ctrl_c = async {
|
||||
tokio::signal::ctrl_c()
|
||||
.await
|
||||
.expect("Ctrl-C-Handler konnte nicht installiert werden");
|
||||
};
|
||||
|
||||
#[cfg(unix)]
|
||||
let terminate = async {
|
||||
tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
|
||||
.expect("SIGTERM-Handler konnte nicht installiert werden")
|
||||
.recv()
|
||||
.await;
|
||||
};
|
||||
#[cfg(not(unix))]
|
||||
let terminate = std::future::pending::<()>();
|
||||
|
||||
tokio::select! {
|
||||
_ = ctrl_c => {},
|
||||
_ = terminate => {},
|
||||
}
|
||||
|
||||
tracing::info!("shutdown signal empfangen — gebe GSD-Lizenz frei");
|
||||
gsd_service.release_license().await;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user