Add CPU and memory usage to service status

src/app/api.rs

@@ -32,6 +32,8 @@ pub struct Status {
     pub state: String,
     pub target: String,
     pub after: HashMap<String, String>,
+    pub memory_kb: u64,
+    pub cpu_percent: f64,
 }
 
 pub struct Api {
@@ -224,6 +226,8 @@ impl Api {
                 }
                 after
             },
+            memory_kb: status.memory_kb,
+            cpu_percent: status.cpu_percent,
         };
 
         Ok(encoder::to_value(result)?)

src/bin/testapp.rs

@@ -1,9 +1,9 @@
 extern crate zinit;
 
 use anyhow::Result;
+use std::env;
 use std::path::Path;
 use tokio::time::{sleep, Duration};
-use std::env;
 
 use zinit::app::api::Client;
 use zinit::testapp;
@@ -12,8 +12,16 @@
 async fn main() -> Result<()> {
     // Define paths for socket and config
     let temp_dir = env::temp_dir();
-    let socket_path = temp_dir.join("zinit-test.sock").to_str().unwrap().to_string();
-    let config_dir = temp_dir.join("zinit-test-config").to_str().unwrap().to_string();
+    let socket_path = temp_dir
+        .join("zinit-test.sock")
+        .to_str()
+        .unwrap()
+        .to_string();
+    let config_dir = temp_dir
+        .join("zinit-test-config")
+        .to_str()
+        .unwrap()
+        .to_string();
 
     println!("Starting zinit with socket at: {}", socket_path);
     println!("Using config directory: {}", config_dir);
@@ -29,16 +37,22 @@
 
     // Create service configurations
     println!("Creating service configurations...");
-    
+
     // Create a find service
-    testapp::create_service_config(&config_dir, "find-service", "find / -name \"*.txt\" -type f").await?;
-
+    testapp::create_service_config(
+        &config_dir,
+        "find-service",
+        "find / -name \"*.txt\" -type f",
+    )
+    .await?;
+
     // Create a sleep service with echo
     testapp::create_service_config(
-        &config_dir, 
-        "sleep-service", 
-        "sh -c 'echo Starting sleep; sleep 30; echo Finished sleep'"
-    ).await?;
+        &config_dir,
+        "sleep-service",
+        "sh -c 'echo Starting sleep; sleep 30; echo Finished sleep'",
+    )
+    .await?;
 
     // Wait for zinit to load the configurations
     sleep(Duration::from_secs(1)).await;
@@ -58,7 +72,7 @@
     // Start the find service
     println!("\nStarting find-service...");
     client.start("find-service").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("find-service").await?;
@@ -67,7 +81,7 @@
     // Start the sleep service
     println!("\nStarting sleep-service...");
     client.start("sleep-service").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("sleep-service").await?;
@@ -76,7 +90,7 @@
     // Stop the find service
     println!("\nStopping find-service...");
     client.stop("find-service").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("find-service").await?;
@@ -85,15 +99,16 @@
     // Kill the sleep service with SIGTERM
     println!("\nKilling sleep-service with SIGTERM...");
     client.kill("sleep-service", "SIGTERM").await?;
-    
+
     // Wait a bit and check status
     sleep(Duration::from_secs(2)).await;
     let status = client.status("sleep-service").await?;
     println!("sleep-service status after killing: {:?}", status);
 
     // Cleanup - forget services
     println!("\nForgetting services...");
-    if status.pid == 0 {  // Only forget if it's not running
+    if status.pid == 0 {
+        // Only forget if it's not running
         client.forget("sleep-service").await?;
     }
     client.forget("find-service").await?;
@@ -104,4 +119,4 @@
 
     println!("\nTest completed successfully!");
     Ok(())
-}
+}

src/lib.rs

@@ -7,5 +7,5 @@ extern crate tokio;
 
 pub mod app;
 pub mod manager;
+pub mod testapp;
 pub mod zinit;
-pub mod testapp;

src/testapp/mod.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
+use std::env;
 use std::path::Path;
+use std::process::Stdio;
 use tokio::process::Command;
 use tokio::time::{sleep, Duration};
-use std::process::Stdio;
-use std::env;
 
 pub async fn start_zinit(socket_path: &str, config_dir: &str) -> Result<()> {
     // Create a temporary config directory if it doesn't exist
@@ -27,12 +27,12 @@ pub async fn start_zinit(socket_path: &str, config_dir: &str) -> Result<()> {
         .stderr(Stdio::piped());
 
     let child = cmd.spawn()?;
-    
+
     // Give zinit some time to start up
     sleep(Duration::from_secs(1)).await;
-    
+
     println!("Zinit started with PID: {:?}", child.id());
-    
+
     Ok(())
 }
 
@@ -54,4 +54,4 @@ dir: /
 
     tokio::fs::write(config_path, config_content).await?;
     Ok(())
-}
+}

src/zinit/errors.rs

@@ -59,16 +59,22 @@ impl ZInitError {
 
     /// Create a new InvalidStateTransition error
     pub fn invalid_state_transition<S: Into<String>>(message: S) -> Self {
-        ZInitError::InvalidStateTransition { message: message.into() }
+        ZInitError::InvalidStateTransition {
+            message: message.into(),
+        }
     }
 
     /// Create a new DependencyError error
     pub fn dependency_error<S: Into<String>>(message: S) -> Self {
-        ZInitError::DependencyError { message: message.into() }
+        ZInitError::DependencyError {
+            message: message.into(),
+        }
     }
 
     /// Create a new ProcessError error
     pub fn process_error<S: Into<String>>(message: S) -> Self {
-        ZInitError::ProcessError { message: message.into() }
+        ZInitError::ProcessError {
+            message: message.into(),
+        }
     }
-}
+}