feat: v3.0.4

Author: eastspire

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "server-manager"
-version = "3.0.2"
+version = "3.0.4"
 edition = "2021"
 authors = ["ltpp-universe <root@ltpp.vip>"] 
 license = "MIT"

Cargo.toml

@@ -2,6 +2,7 @@ pub(crate) mod cfg;
 pub(crate) mod config;
 pub(crate) mod manager;
 
+pub(crate) use manager::constant::*;
 #[allow(unused_imports)]
 pub(crate) use std::{
     fs,

src/lib.rs

@@ -0,0 +1,2 @@
+pub static RUNNING_AS_DAEMON: &str = "RUNNING_AS_DAEMON";
+pub static RUNNING_AS_DAEMON_VALUE: &str = "RUNNING_AS_DAEMON";

src/manager/constant.rs

@@ -59,9 +59,9 @@ where
     /// - `Result<(), Box<dyn std::error::Error>>`: Operation result.
     ///
     /// This function returns an error because daemon mode is not supported on non-Unix platforms.
-    #[cfg(unix)]
+    #[cfg(not(windows))]
     pub fn start_daemon(&self) -> Result<(), Box<dyn std::error::Error>> {
-        if std::env::var("RUNNING_AS_DAEMON").is_ok() {
+        if std::env::var(RUNNING_AS_DAEMON).is_ok() {
             self.write_pid_file()?;
             let rt: Runtime = Runtime::new()?;
             rt.block_on(async {
@@ -71,18 +71,44 @@ where
         }
         let exe_path: PathBuf = std::env::current_exe()?;
         let mut cmd: Command = Command::new(exe_path);
-        cmd.env("RUNNING_AS_DAEMON", "1")
+        cmd.env(RUNNING_AS_DAEMON, RUNNING_AS_DAEMON_VALUE)
             .stdout(Stdio::from(fs::File::create(&self.config.stdout_log)?))
             .stderr(Stdio::from(fs::File::create(&self.config.stderr_log)?))
             .stdin(Stdio::null());
         cmd.spawn()?;
         exit(0);
     }
 
-    /// 在非 Unix 平台下返回错误。
-    #[cfg(not(unix))]
+    #[cfg(windows)]
+    /// Start the server in daemon (background) mode on Windows platforms
+    /// Title: Start the server in daemon mode on Windows platforms
+    ///
+    /// Parameters:
+    /// - None
+    ///
+    /// Returns:
+    /// - `Result<(), Box<dyn std::error::Error>>`: Operation result.
+    ///
+    /// This function starts a detached process on Windows using Windows API.
     pub fn start_daemon(&self) -> Result<(), Box<dyn std::error::Error>> {
-        Err("Daemon mode is not supported on non-Unix platforms".into())
+        use std::os::windows::process::CommandExt;
+        if std::env::var(RUNNING_AS_DAEMON).is_ok() {
+            self.write_pid_file()?;
+            let rt: Runtime = Runtime::new()?;
+            rt.block_on(async {
+                (self.server_fn)().await;
+            });
+            return Ok(());
+        }
+        let exe_path: PathBuf = std::env::current_exe()?;
+        let mut cmd: Command = Command::new(exe_path);
+        cmd.env(RUNNING_AS_DAEMON, RUNNING_AS_DAEMON_VALUE)
+            .stdout(Stdio::from(fs::File::create(&self.config.stdout_log)?))
+            .stderr(Stdio::from(fs::File::create(&self.config.stderr_log)?))
+            .stdin(Stdio::null())
+            .creation_flags(0x00000008);
+        cmd.spawn()?;
+        std::process::exit(0);
     }
 
     /// Title: Read process ID from the PID file
@@ -127,7 +153,7 @@ where
     /// - `Result<(), Box<dyn std::error::Error>>`: Operation result.
     ///
     /// This function sends a SIGTERM signal to the process with the given PID using libc::kill.
-    #[cfg(unix)]
+    #[cfg(not(windows))]
     fn kill_process(&self, pid: i32) -> Result<(), Box<dyn std::error::Error>> {
         let result: Result<std::process::Output, std::io::Error> = Command::new("kill")
             .arg("-TERM")
@@ -145,18 +171,64 @@ where
         }
     }
 
-    /// Title: Kill process by PID on non-Unix platforms
+    #[cfg(windows)]
+    /// Kill process by PID on Windows platforms
+    /// Title: Kill process by PID on Windows platforms
     ///
     /// Parameters:
-    /// - `pid`: The process ID to kill.
+    /// - ``pid``: The process ID to kill.
     ///
     /// Returns:
-    /// - `Result<(), Box<dyn std::error::Error>>`: Operation result.
+    /// - ``Result<(), Box<dyn std::error::Error>>``: Operation result.
     ///
-    /// This function returns an error because killing a process is not supported on non-Unix platforms.
-
-    #[cfg(not(unix))]
-    fn kill_process(&self, _pid: i32) -> Result<(), Box<dyn std::error::Error>> {
-        Err("kill_process is not supported on non-Unix platforms".into())
+    /// This function attempts to kill the process with the given PID using Windows API.
+    /// If opening or terminating the process fails, the detailed error code is returned.
+    fn kill_process(&self, pid: i32) -> Result<(), Box<dyn std::error::Error>> {
+        use std::ffi::c_void;
+        type DWORD = u32;
+        type BOOL = i32;
+        type HANDLE = *mut c_void;
+        type UINT = u32;
+        const PROCESS_TERMINATE: DWORD = 0x0001;
+        const PROCESS_ALL_ACCESS: DWORD = 0x1F0FFF;
+        extern "system" {
+            fn OpenProcess(
+                dwDesiredAccess: DWORD,
+                bInheritHandle: BOOL,
+                dwProcessId: DWORD,
+            ) -> HANDLE;
+            fn TerminateProcess(hProcess: HANDLE, uExitCode: UINT) -> BOOL;
+            fn CloseHandle(hObject: HANDLE) -> BOOL;
+            fn GetLastError() -> DWORD;
+        }
+        let process_id: DWORD = pid as DWORD;
+        let mut process_handle: HANDLE = unsafe { OpenProcess(PROCESS_TERMINATE, 0, process_id) };
+        if process_handle.is_null() {
+            process_handle = unsafe { OpenProcess(PROCESS_ALL_ACCESS, 0, process_id) };
+        }
+        if process_handle.is_null() {
+            let error_code = unsafe { GetLastError() };
+            return Err(format!(
+                "Failed to open process with pid: {}. Error code: {}",
+                pid, error_code
+            )
+            .into());
+        }
+        let terminate_result: BOOL = unsafe { TerminateProcess(process_handle, 1) };
+        if terminate_result == 0 {
+            let error_code = unsafe { GetLastError() };
+            unsafe {
+                CloseHandle(process_handle);
+            }
+            return Err(format!(
+                "Failed to terminate process with pid: {}. Error code: {}",
+                pid, error_code
+            )
+            .into());
+        }
+        unsafe {
+            CloseHandle(process_handle);
+        }
+        Ok(())
     }
 }

src/manager/impl.rs

@@ -1,2 +1,3 @@
+pub(crate) mod constant;
 pub(crate) mod r#impl;
 pub(crate) mod r#type;