created zinit client library

Author: maximevanhees

Cargo.lock

@@ -1,3 +1,9 @@
+[workspace]
+members = [
+    ".",
+    "zinit-client"
+]
+
 [package]
 name = "zinit"
 version = "0.2.0"

Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "zinit-client"
+version = "0.1.0"
+edition = "2021"
+description = "A client library for interacting with Zinit process manager"
+license = "MIT"
+authors = ["ThreeFold Tech, https://github.com/threefoldtech"]
+
+[dependencies]
+anyhow = "1.0"
+tokio = { version = "1.14.0", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", features = ["json"] }
+thiserror = "1.0"
+log = "0.4"
+
+[[example]]
+name = "basic_usage"
+path = "examples/basic_usage.rs"
+
+[[example]]
+name = "http_client"
+path = "examples/http_client.rs"
+log = "0.4"

zinit-client/Cargo.toml

@@ -0,0 +1,123 @@
+# Zinit Client Library
+
+A simple Rust client library for interacting with the Zinit process manager.
+
+## Features
+
+- Connect to Zinit via Unix socket or HTTP
+- Manage services (start, stop, restart, monitor)
+- Query service status and information
+- Create and delete service configurations
+- System operations (shutdown, reboot)
+
+## Installation
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+zinit-client = "0.1.0"
+```
+
+## Usage
+
+### Creating a Client
+
+You can create a client using either Unix socket or HTTP transport:
+
+```rust
+use zinit_client::Client;
+
+// Using Unix socket (local only)
+let client = Client::unix_socket("/var/run/zinit.sock");
+
+// Using HTTP (works for remote Zinit instances)
+let client = Client::http("http://localhost:8080");
+```
+
+### Service Management
+
+```rust
+// List all services
+let services = client.list().await?;
+for (name, state) in services {
+    println!("{}: {}", name, state);
+}
+
+// Get status of a specific service
+let status = client.status("my-service").await?;
+println!("PID: {}, State: {}", status.pid, status.state);
+
+// Start a service
+client.start("my-service").await?;
+
+// Stop a service
+client.stop("my-service").await?;
+
+// Restart a service
+client.restart("my-service").await?;
+
+// Monitor a service
+client.monitor("my-service").await?;
+
+// Forget a service
+client.forget("my-service").await?;
+
+// Send a signal to a service
+client.kill("my-service", "SIGTERM").await?;
+```
+
+### Service Configuration
+
+```rust
+use serde_json::json;
+
+// Create a new service
+let config = json!({
+    "exec": "nginx",
+    "oneshot": false,
+    "after": ["network"]
+}).as_object().unwrap().clone();
+
+client.create_service("nginx", config).await?;
+
+// Get service configuration
+let config = client.get_service("nginx").await?;
+println!("Config: {:?}", config);
+
+// Delete a service
+client.delete_service("nginx").await?;
+```
+
+### System Operations
+
+```rust
+// Shutdown the system
+client.shutdown().await?;
+
+// Reboot the system
+client.reboot().await?;
+```
+
+## Error Handling
+
+The library provides a `ClientError` enum for handling errors:
+
+```rust
+match client.status("non-existent-service").await {
+    Ok(status) => println!("Service status: {}", status.state),
+    Err(e) => match e {
+        ClientError::ServiceNotFound(_) => println!("Service not found"),
+        ClientError::ConnectionError(_) => println!("Failed to connect to Zinit"),
+        _ => println!("Other error: {}", e),
+    },
+}
+```
+
+## Examples
+
+See the [examples](examples) directory for complete usage examples.
+
+## License
+
+This project is licensed under the MIT License.

zinit-client/README.md

@@ -0,0 +1,99 @@
+use anyhow::Result;
+use serde_json::json;
+use std::time::Duration;
+use tokio::time;
+use zinit_client::Client;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Create a client using Unix socket transport
+    // let unix_client = Client::unix_socket("/var/run/zinit.sock");
+    
+    // Or create a client using HTTP transport
+    let http_client = Client::http("http://localhost:8080");
+    
+    // Choose which client to use for this example
+    let client = http_client;
+    
+    // Service name for our example
+    let service_name = "test123";
+    
+    // Step 1: List existing services
+    println!("Listing all services before creating our test service:");
+    let services = client.list().await?;
+    
+    // Print all services
+    for (name, state) in &services {
+        println!("- {}: {}", name, state);
+    }
+    
+    // Step 2: Create a new service
+    println!("\n--- Creating service '{}' ---", service_name);
+    
+    // Create the service configuration
+    let service_config = json!({
+        "exec": "echo 'test123 hello'",
+        "oneshot": false,
+        "log": "stdout"
+    }).as_object().unwrap().clone();
+    
+    // Create the service
+    let result = client.create_service(service_name, service_config).await?;
+    println!("Create result: {}", result);
+    
+    // Step 3: Monitor the service
+    println!("\n--- Monitoring service '{}' ---", service_name);
+    client.monitor(service_name).await?;
+    println!("Service is now being monitored");
+    
+    // Wait a moment for the service to start
+    println!("Waiting for service to start...");
+    time::sleep(Duration::from_secs(2)).await;
+    
+    // Step 4: Get the status of the service
+    println!("\n--- Getting status for '{}' ---", service_name);
+    let status = client.status(service_name).await?;
+    println!("Name: {}", status.name);
+    println!("PID: {}", status.pid);
+    println!("State: {}", status.state);
+    println!("Target: {}", status.target);
+    println!("Dependencies:");
+    for (dep, state) in &status.after {
+        println!("  - {}: {}", dep, state);
+    }
+    
+    // Step 5: Stop the service
+    println!("\n--- Stopping service '{}' ---", service_name);
+    client.stop(service_name).await?;
+    println!("Service stopped");
+    
+    // Wait a moment for the service to stop
+    time::sleep(Duration::from_secs(1)).await;
+    
+    // Check status after stopping
+    println!("\n--- Status after stopping ---");
+    let status = client.status(service_name).await?;
+    println!("State: {}", status.state);
+    println!("Target: {}", status.target);
+    
+    // Step 6: Delete the service
+    println!("\n--- Deleting service '{}' ---", service_name);
+    let delete_result = client.delete_service(service_name).await?;
+    println!("Delete result: {}", delete_result);
+    
+    // Step 7: Verify the service is gone
+    println!("\n--- Listing services after deletion ---");
+    let services_after = client.list().await?;
+    for (name, state) in &services_after {
+        println!("- {}: {}", name, state);
+    }
+    
+    // Check if our service was deleted
+    if !services_after.contains_key(service_name) {
+        println!("\nService '{}' was successfully deleted", service_name);
+    } else {
+        println!("\nWarning: Service '{}' still exists", service_name);
+    }
+    
+    Ok(())
+}

zinit-client/examples/basic_usage.rs

@@ -0,0 +1,45 @@
+use anyhow::Result;
+use zinit_client::Client;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Create a client using HTTP transport
+    let client = Client::http("http://localhost:8080");
+    
+    println!("Connecting to Zinit via HTTP...");
+    
+    // List all services
+    println!("Listing all services:");
+    match client.list().await {
+        Ok(services) => {
+            if services.is_empty() {
+                println!("No services found.");
+            } else {
+                for (name, state) in &services {
+                    println!("- {}: {}", name, state);
+                }
+                
+                // Try to get the first service for a status example
+                if let Some(service_name) = services.keys().next() {
+                    println!("\nGetting status for {}:", service_name);
+                    match client.status(service_name).await {
+                        Ok(status) => {
+                            println!("Name: {}", status.name);
+                            println!("PID: {}", status.pid);
+                            println!("State: {}", status.state);
+                            println!("Target: {}", status.target);
+                            println!("Dependencies: {}", status.after.len());
+                        },
+                        Err(e) => println!("Error getting status: {}", e),
+                    }
+                }
+            }
+        },
+        Err(e) => {
+            println!("Error connecting to Zinit HTTP proxy: {}", e);
+            println!("Make sure the Zinit HTTP proxy is running on http://localhost:8080");
+        }
+    }
+    
+    Ok(())
+}