feat: v3.7.0

Author: eastspire

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "server-manager"
-version = "3.6.0"
+version = "3.7.0"
 readme = "README.md"
 edition = "2024"
 authors = ["root@ltpp.vip"]

README.md

@@ -35,16 +35,16 @@ let pid_file: String = "./process/test_pid.pid".to_string();
 let _ = fs::remove_file(&pid_file);
 let mut config = ServerManagerConfig::new(pid_file.clone());
 config
-    .set_before_start_daemon_hook(|| async {
+    .set_start_hook(|| async {
         println!("Before start daemon hook executed");
     })
-    .set_before_stop_hook(|| async {
+    .set_stop_hook(|| async {
         println!("Before stop hook executed");
     });
-let dummy_server = || async {
+let server = || async {
     tokio::time::sleep(Duration::from_secs(1)).await;
 };
-let manager = ServerManager::new(config, dummy_server);
+let manager = ServerManager::new(config, server);
 let res: ServerManagerResult = manager.start_daemon().await;
 println!("start_daemon {:?}", res);
 let res: ServerManagerResult = manager.stop().await;

src/cfg.rs

@@ -8,16 +8,16 @@ async fn test_start_executes_server_fn() {
     let _ = fs::remove_file(&pid_file);
     let mut config = ServerManagerConfig::new(pid_file.clone());
     config
-        .set_before_start_daemon_hook(|| async {
+        .set_start_hook(|| async {
             println!("Before start daemon hook executed");
         })
-        .set_before_stop_hook(|| async {
+        .set_stop_hook(|| async {
             println!("Before stop hook executed");
         });
-    let dummy_server = || async {
+    let server = || async {
         tokio::time::sleep(Duration::from_secs(1)).await;
     };
-    let manager = ServerManager::new(config, dummy_server);
+    let manager = ServerManager::new(config, server);
     let res: ServerManagerResult = manager.start_daemon().await;
     println!("start_daemon {:?}", res);
     let res: ServerManagerResult = manager.stop().await;

src/config/impl.rs

@@ -13,34 +13,34 @@ impl ServerManagerConfig {
         self
     }
 
-    pub fn set_before_stop_hook<F, Fut>(&mut self, f: F) -> &mut Self
+    pub fn set_stop_hook<F, Fut>(&mut self, f: F) -> &mut Self
     where
         F: Fn() -> Fut + Send + Sync + 'static,
         Fut: Future<Output = ()> + Send + 'static,
     {
-        self.before_stop_hook = Arc::new(move || Box::pin(f()));
+        self.stop_hook = Arc::new(move || Box::pin(f()));
         self
     }
 
-    pub fn set_before_start_daemon_hook<F, Fut>(&mut self, f: F) -> &mut Self
+    pub fn set_start_hook<F, Fut>(&mut self, f: F) -> &mut Self
     where
         F: Fn() -> Fut + Send + Sync + 'static,
         Fut: Future<Output = ()> + Send + 'static,
     {
-        self.before_start_daemon_hook = Arc::new(move || Box::pin(f()));
+        self.start_hook = Arc::new(move || Box::pin(f()));
         self
     }
 
     pub fn get_pid_file(&self) -> &str {
         &self.pid_file
     }
 
-    pub fn get_before_stop_hook(&self) -> &Hook {
-        &self.before_stop_hook
+    pub fn get_stop_hook(&self) -> &Hook {
+        &self.stop_hook
     }
 
-    pub fn get_before_start_daemon_hook(&self) -> &Hook {
-        &self.before_start_daemon_hook
+    pub fn get_start_hook(&self) -> &Hook {
+        &self.start_hook
     }
 }
 
@@ -49,8 +49,8 @@ impl Default for ServerManagerConfig {
         let empty_hook: Hook = Arc::new(|| Box::pin(async {}));
         Self {
             pid_file: Default::default(),
-            before_stop_hook: empty_hook.clone(),
-            before_start_daemon_hook: empty_hook,
+            stop_hook: empty_hook.clone(),
+            start_hook: empty_hook,
         }
     }
 }

src/config/struct.rs

@@ -8,7 +8,7 @@ pub struct ServerManagerConfig {
     /// Path to the PID file for process tracking.
     pub(crate) pid_file: String,
     /// An asynchronous function to be called before stopping the server.
-    pub(crate) before_stop_hook: Hook,
-    /// An asynchronous function to be called before starting the server daemon.
-    pub(crate) before_start_daemon_hook: Hook,
+    pub(crate) stop_hook: Hook,
+    /// An asynchronous function to be called before starting the server.
+    pub(crate) start_hook: Hook,
 }

src/manager/impl.rs

@@ -41,15 +41,15 @@ where
     ///
     /// - `ServerManagerResult` - Operation result.
     pub async fn stop(&self) -> ServerManagerResult {
-        (self.config.before_stop_hook)().await;
+        (self.config.stop_hook)().await;
         let pid: i32 = self.read_pid_file()?;
         self.kill_process(pid)
     }
 
     /// Starts the server in daemon (background) mode on Unix platforms.
     #[cfg(not(windows))]
     pub async fn start_daemon(&self) -> ServerManagerResult {
-        (self.config.before_start_daemon_hook)().await;
+        (self.config.start_hook)().await;
         if std::env::var(RUNNING_AS_DAEMON).is_ok() {
             self.write_pid_file()?;
             let rt: Runtime = Runtime::new()?;
@@ -72,7 +72,7 @@ where
     /// Starts the server in daemon (background) mode on Windows platforms.
     #[cfg(windows)]
     pub async fn start_daemon(&self) -> ServerManagerResult {
-        (self.config.before_start_daemon_hook)().await;
+        (self.config.start_hook)().await;
         use std::os::windows::process::CommandExt;
         if std::env::var(RUNNING_AS_DAEMON).is_ok() {
             self.write_pid_file()?;