fix：more platform

rustfs/src/main.rs

@@ -324,14 +324,6 @@ async fn run(opt: config::Opt) -> Result<()> {
             (sigterm_inner, sigint_inner)
         };
 
-        #[cfg(not(unix))]
-        let (mut sigterm_inner, mut sigint_inner) = {
-            // Windows platform uses Ctrl+C as the only signal source
-            // Create two never-finished futures as placeholders
-            info!("Running on Windows, only Ctrl+C signal will be handled");
-            (std::pin::pin!(std::future::pending::<()>()), std::pin::pin!(std::future::pending::<()>()))
-        };
-
         let hybrid_service = TowerToHyperService::new(
             tower::ServiceBuilder::new()
                 .layer(
@@ -392,38 +384,69 @@ async fn run(opt: config::Opt) -> Result<()> {
         loop {
             debug!("waiting for SIGINT or SIGTERM has_tls_certs: {}", has_tls_certs);
             // Wait for a connection
-            let (socket, _) = tokio::select! {
-                res = listener.accept() => {
-                    match res {
-                        Ok(conn) => conn,
-                        Err(err) => {
-                            error!("error accepting connection: {err}");
-                            continue;
+            // Wait for a connection
+            let (socket, _) = {
+                #[cfg(unix)]
+                {
+                    tokio::select! {
+                        res = listener.accept() => {
+                            match res {
+                                Ok(conn) => conn,
+                                Err(err) => {
+                                    error!("error accepting connection: {err}");
+                                    continue;
+                                }
+                            }
+                        }
+
+                        _ = ctrl_c.as_mut() => {
+                            info!("Ctrl-C received in worker thread");
+                            let _ = shutdown_tx_clone.send(());
+                            break;
+                        }
+
+                       Some(_) = sigint_inner.recv() => {
+                           info!("SIGINT received in worker thread");
+                           let _ = shutdown_tx_clone.send(());
+                           break;
+                       }
+
+                       Some(_) = sigterm_inner.recv() => {
+                           info!("SIGTERM received in worker thread");
+                           let _ = shutdown_tx_clone.send(());
+                           break;
+                       }
+
+                        _ = shutdown_rx.recv() => {
+                            info!("Shutdown signal received in worker thread");
+                            break;
                         }
                     }
                 }
+                #[cfg(not(unix))]
+                {
+                    tokio::select! {
+                        res = listener.accept() => {
+                            match res {
+                                Ok(conn) => conn,
+                                Err(err) => {
+                                    error!("error accepting connection: {err}");
+                                    continue;
+                                }
+                            }
+                        }
 
-                _ = ctrl_c.as_mut() => {
-                    info!("Ctrl-C received in worker thread");
-                    let _ = shutdown_tx_clone.send(());
-                    break;
-                }
+                        _ = ctrl_c.as_mut() => {
+                            info!("Ctrl-C received in worker thread");
+                            let _ = shutdown_tx_clone.send(());
+                            break;
+                        }
 
-               Some(_) = sigint_inner.recv() => {
-                   info!("SIGINT received in worker thread");
-                   let _ = shutdown_tx_clone.send(());
-                   break;
-               }
-
-               Some(_) = sigterm_inner.recv() => {
-                   info!("SIGTERM received in worker thread");
-                   let _ = shutdown_tx_clone.send(());
-                   break;
-               }
-
-                _ = shutdown_rx.recv() => {
-                    info!("Shutdown signal received in worker thread");
-                    break;
+                        _ = shutdown_rx.recv() => {
+                            info!("Shutdown signal received in worker thread");
+                            break;
+                        }
+                    }
                 }
             };
 

rustfs/src/server/service_state.rs

@@ -1,9 +1,7 @@
 use atomic_enum::atomic_enum;
-use std::sync::Arc;
 use std::sync::atomic::Ordering;
+use std::sync::Arc;
 use std::time::Duration;
-#[cfg(unix)]
-use tokio::signal::unix::{SignalKind, signal};
 use tracing::info;
 
 // a configurable shutdown timeout
@@ -11,7 +9,7 @@ pub(crate) const SHUTDOWN_TIMEOUT: Duration = Duration::from_secs(1);
 
 #[cfg(target_os = "linux")]
 fn notify_systemd(state: &str) {
-    use libsystemd::daemon::{NotifyState, notify};
+    use libsystemd::daemon::{notify, NotifyState};
     use tracing::{debug, error};
     let notify_state = match state {
         "ready" => NotifyState::Ready,
@@ -51,7 +49,9 @@ pub(crate) enum ServiceState {
     Stopped,
 }
 
+#[cfg(unix)]
 pub(crate) async fn wait_for_shutdown() -> ShutdownSignal {
+    use tokio::signal::unix::{signal, SignalKind};
     let mut sigterm = signal(SignalKind::terminate()).expect("failed to create SIGTERM signal handler");
     let mut sigint = signal(SignalKind::interrupt()).expect("failed to create SIGINT signal handler");
 
@@ -71,6 +71,16 @@ pub(crate) async fn wait_for_shutdown() -> ShutdownSignal {
     }
 }
 
+#[cfg(not(unix))]
+pub(crate) async fn wait_for_shutdown() -> ShutdownSignal {
+    tokio::select! {
+        _ = tokio::signal::ctrl_c() => {
+            info!("Received Ctrl-C signal");
+            ShutdownSignal::CtrlC
+        }
+    }
+}
+
 #[derive(Clone)]
 pub(crate) struct ServiceStateManager {
     state: Arc<AtomicServiceState>,