sal_zinit_client/

lib.rs

//! SAL Zinit Client
//!
//! This crate provides a Rust interface for interacting with a Zinit process supervisor daemon.
//! Zinit is a process and service manager for Linux systems, designed for simplicity and robustness.
//!
//! # Features
//!
//! - Async operations using tokio
//! - Unix socket communication with Zinit daemon
//! - Global client instance management
//! - Comprehensive service management (start, stop, restart, monitor, etc.)
//! - Service configuration management (create, delete, get)
//! - Log retrieval from Zinit
//! - Rhai scripting integration
//!
//! # Example
//!
//! ```rust,no_run
//! use sal_zinit_client::{list, status};
//!
//! #[tokio::main]
//! async fn main() -> Result<(), Box<dyn std::error::Error>> {
//!     let socket_path = "/var/run/zinit.sock";
//!     
//!     // List all services
//!     let services = list(socket_path).await?;
//!     println!("Services: {:?}", services);
//!     
//!     // Get status of a specific service
//!     if let Some(service_name) = services.keys().next() {
//!         let status = status(socket_path, service_name).await?;
//!         println!("Status: {:?}", status);
//!     }
//!     
//!     Ok(())
//! }
//! ```

pub mod rhai;

use lazy_static::lazy_static;
use serde_json::Value;
use std::collections::HashMap;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use zinit_client::{ServiceState, ServiceStatus as Status, ZinitClient, ZinitError};

// Global Zinit client instance using lazy_static
lazy_static! {
    static ref ZINIT_CLIENT: Mutex<Option<Arc<ZinitClientWrapper>>> = Mutex::new(None);
}

// Wrapper for Zinit client to handle connection
pub struct ZinitClientWrapper {
    client: ZinitClient,
    initialized: AtomicBool,
}

impl ZinitClientWrapper {
    // Create a new Zinit client wrapper
    fn new(client: ZinitClient) -> Self {
        ZinitClientWrapper {
            client,
            initialized: AtomicBool::new(false),
        }
    }

    // Initialize the client
    async fn initialize(&self) -> Result<(), ZinitError> {
        if self.initialized.load(Ordering::Relaxed) {
            return Ok(());
        }

        // Try to list services to check if the connection works
        let _ = self.client.list().await.map_err(|e| {
            log::error!("Failed to initialize Zinit client: {}", e);
            e
        })?;

        self.initialized.store(true, Ordering::Relaxed);
        Ok(())
    }

    // List all services
    pub async fn list(&self) -> Result<HashMap<String, ServiceState>, ZinitError> {
        self.client.list().await
    }

    // Get status of a service
    pub async fn status(&self, name: &str) -> Result<Status, ZinitError> {
        self.client.status(name).await
    }

    // Start a service
    pub async fn start(&self, name: &str) -> Result<(), ZinitError> {
        self.client.start(name).await
    }

    // Stop a service
    pub async fn stop(&self, name: &str) -> Result<(), ZinitError> {
        self.client.stop(name).await
    }

    // Restart a service
    pub async fn restart(&self, name: &str) -> Result<(), ZinitError> {
        self.client.restart(name).await
    }

    // Monitor a service
    pub async fn monitor(&self, name: &str) -> Result<(), ZinitError> {
        self.client.monitor(name).await
    }

    // Forget a service (stop monitoring)
    pub async fn forget(&self, name: &str) -> Result<(), ZinitError> {
        self.client.forget(name).await
    }

    // Kill a service
    pub async fn kill(&self, name: &str, signal: Option<&str>) -> Result<(), ZinitError> {
        let signal_str = signal.unwrap_or("TERM");
        self.client.kill(name, signal_str).await
    }

    // Create a service
    pub async fn create_service(
        &self,
        name: &str,
        service_config: Value,
    ) -> Result<(), ZinitError> {
        self.client.create_service(name, service_config).await
    }

    // Delete a service
    pub async fn delete_service(&self, name: &str) -> Result<(), ZinitError> {
        self.client.delete_service(name).await
    }

    // Get service configuration
    pub async fn get_service(&self, name: &str) -> Result<Value, ZinitError> {
        self.client.get_service(name).await
    }

    // Reboot the system
    pub async fn reboot(&self) -> Result<(), ZinitError> {
        self.client.reboot().await
    }

    // Get logs with real implementation
    pub async fn logs(&self, filter: Option<String>) -> Result<Vec<String>, ZinitError> {
        use futures::StreamExt;

        // The logs method requires a follow parameter and filter
        let follow = false; // Don't follow logs, just get existing ones
        let mut log_stream = self.client.logs(follow, filter).await?;
        let mut logs = Vec::new();

        // Collect logs from the stream with a reasonable limit
        let mut count = 0;
        const MAX_LOGS: usize = 1000;

        while let Some(log_result) = log_stream.next().await {
            match log_result {
                Ok(log_entry) => {
                    // Convert LogEntry to String using Debug formatting
                    logs.push(format!("{:?}", log_entry));
                    count += 1;
                    if count >= MAX_LOGS {
                        break;
                    }
                }
                Err(e) => {
                    log::warn!("Error reading log entry: {}", e);
                    break;
                }
            }
        }

        Ok(logs)
    }
}

// Get the Zinit client instance
pub async fn get_zinit_client(socket_path: &str) -> Result<Arc<ZinitClientWrapper>, ZinitError> {
    // Check if we already have a client
    {
        let guard = ZINIT_CLIENT.lock().unwrap();
        if let Some(ref client) = &*guard {
            return Ok(Arc::clone(client));
        }
    }

    // Create a new client
    let client = create_zinit_client(socket_path).await?;

    // Store the client globally
    {
        let mut guard = ZINIT_CLIENT.lock().unwrap();
        *guard = Some(Arc::clone(&client));
    }

    Ok(client)
}

// Create a new Zinit client
async fn create_zinit_client(socket_path: &str) -> Result<Arc<ZinitClientWrapper>, ZinitError> {
    // Connect via Unix socket
    let client = ZinitClient::new(socket_path);
    let wrapper = Arc::new(ZinitClientWrapper::new(client));

    // Initialize the client
    wrapper.initialize().await?;

    Ok(wrapper)
}

// Reset the Zinit client
pub async fn reset(socket_path: &str) -> Result<(), ZinitError> {
    // Clear the existing client
    {
        let mut client_guard = ZINIT_CLIENT.lock().unwrap();
        *client_guard = None;
    }

    // Create a new client, only return error if it fails
    get_zinit_client(socket_path).await?;
    Ok(())
}

// Convenience functions for common operations

// List all services - convert ServiceState to String for compatibility
pub async fn list(socket_path: &str) -> Result<HashMap<String, String>, ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    let services = client.list().await?;

    // Convert HashMap<String, ServiceState> to HashMap<String, String>
    let mut result = HashMap::new();
    for (name, state) in services {
        result.insert(name, format!("{:?}", state));
    }

    Ok(result)
}

// Get status of a service
pub async fn status(socket_path: &str, name: &str) -> Result<Status, ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.status(name).await
}

// Start a service
pub async fn start(socket_path: &str, name: &str) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.start(name).await
}

// Stop a service
pub async fn stop(socket_path: &str, name: &str) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.stop(name).await
}

// Restart a service
pub async fn restart(socket_path: &str, name: &str) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.restart(name).await
}

// Monitor a service
pub async fn monitor(socket_path: &str, name: &str) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.monitor(name).await
}

// Forget a service (stop monitoring)
pub async fn forget(socket_path: &str, name: &str) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.forget(name).await
}

// Kill a service
pub async fn kill(socket_path: &str, name: &str, signal: Option<&str>) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.kill(name, signal).await
}

// Create a service with simplified parameters
pub async fn create_service(
    socket_path: &str,
    name: &str,
    exec: &str,
    oneshot: bool,
) -> Result<(), ZinitError> {
    use serde_json::json;

    let service_config = json!({
        "exec": exec,
        "oneshot": oneshot
    });

    let client = get_zinit_client(socket_path).await?;
    client.create_service(name, service_config).await
}

// Create a service with full parameters
pub async fn create_service_full(
    socket_path: &str,
    name: &str,
    exec: &str,
    oneshot: bool,
    after: Option<Vec<String>>,
    env: Option<HashMap<String, String>>,
    log: Option<String>,
    test: Option<String>,
) -> Result<(), ZinitError> {
    use serde_json::json;

    let mut service_config = json!({
        "exec": exec,
        "oneshot": oneshot
    });

    if let Some(after_deps) = after {
        service_config["after"] = json!(after_deps);
    }
    if let Some(environment) = env {
        service_config["env"] = json!(environment);
    }
    if let Some(log_path) = log {
        service_config["log"] = json!(log_path);
    }
    if let Some(test_cmd) = test {
        service_config["test"] = json!(test_cmd);
    }

    let client = get_zinit_client(socket_path).await?;
    client.create_service(name, service_config).await
}

// Delete a service
pub async fn delete_service(socket_path: &str, name: &str) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.delete_service(name).await
}

// Get service configuration
pub async fn get_service(socket_path: &str, name: &str) -> Result<Value, ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.get_service(name).await
}

// Reboot the system
pub async fn reboot(socket_path: &str) -> Result<(), ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.reboot().await
}

// Get logs
pub async fn logs(socket_path: &str, filter: Option<String>) -> Result<Vec<String>, ZinitError> {
    let client = get_zinit_client(socket_path).await?;
    client.logs(filter).await
}