refactor: encapsulate log rotation logic

This moves the `SIGHUP` signal handling from the main server loop to a
dedicated background task in `ServerLogger` to make the logger responsible
for its own file handle management.

Co-Authored-By: Gemini 3.0 Pro

Author: Anyitechs

ldk-server/src/main.rs

@@ -254,14 +254,8 @@ fn main() {
 	}
 
 	runtime.block_on(async {
-		// Register SIGHUP handler for log rotation
-		let mut sighup_stream = match tokio::signal::unix::signal(SignalKind::hangup()) {
-			Ok(stream) => stream,
-			Err(e) => {
-				error!("Failed to register SIGHUP handler: {e}");
-				std::process::exit(-1);
-			}
-		};
+		// Start the logger's signal listener for log rotation
+		logger.start_signal_listener();
 
 		let mut sigterm_stream = match tokio::signal::unix::signal(SignalKind::terminate()) {
 			Ok(stream) => stream,
@@ -517,11 +511,6 @@ fn main() {
 					let _ = shutdown_tx.send(true);
 					break;
 				}
-				_ = sighup_stream.recv() => {
-					if let Err(e) = logger.reopen() {
-						error!("Failed to reopen log file on SIGHUP: {e}");
-					}
-				}
 				_ = sigterm_stream.recv() => {
 					info!("Received SIGTERM, shutting down..");
 					let _ = shutdown_tx.send(true);

ldk-server/src/util/logger.rs

@@ -12,7 +12,9 @@ use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
-use log::{Level, LevelFilter, Log, Metadata, Record};
+use log::{error, info, Level, LevelFilter, Log, Metadata, Record};
+#[cfg(unix)]
+use tokio::signal::unix::{signal, SignalKind};
 
 /// A logger implementation that writes logs to both stderr and a file.
 ///
@@ -61,9 +63,18 @@ impl ServerLogger {
 		log::set_boxed_logger(Box::new(LoggerWrapper(Arc::clone(&logger))))
 			.map_err(io::Error::other)?;
 		log::set_max_level(level);
+
 		Ok(logger)
 	}
 
+	/// Starts a background task to listen for SIGHUP and rotate logs.
+	pub fn start_signal_listener(self: &Arc<Self>) {
+		#[cfg(unix)]
+		{
+			spawn_sighup_handler(Arc::clone(self));
+		}
+	}
+
 	/// Reopens the log file. Called on SIGHUP for log rotation.
 	pub fn reopen(&self) -> Result<(), io::Error> {
 		let new_file = open_log_file(&self.log_file_path)?;
@@ -158,6 +169,28 @@ fn open_log_file(log_file_path: &Path) -> Result<File, io::Error> {
 	OpenOptions::new().create(true).append(true).open(log_file_path)
 }
 
+#[cfg(unix)]
+fn spawn_sighup_handler(logger: Arc<ServerLogger>) {
+	if let Ok(handle) = tokio::runtime::Handle::try_current() {
+		handle.spawn(async move {
+			let mut sighup_stream = match signal(SignalKind::hangup()) {
+				Ok(stream) => stream,
+				Err(e) => {
+					error!("Failed to register SIGHUP handler: {e}");
+					return;
+				},
+			};
+
+			while sighup_stream.recv().await.is_some() {
+				info!("SIGHUP received; reopening log file for rotation...");
+				if let Err(e) = logger.reopen() {
+					error!("Failed to reopen log file on SIGHUP: {e}");
+				}
+			}
+		});
+	}
+}
+
 /// Wrapper to allow Arc<ServerLogger> to implement Log trait
 struct LoggerWrapper(Arc<ServerLogger>);