updated zinit-client to reflect new rpc crates

Author: maximevanhees

Cargo.lock

@@ -45,11 +45,4 @@ path = "src/lib.rs"
 
 [[bin]]
 name = "zinit"
-path = "src/main.rs"
-# [[bin]]
-# name = "testapp"
-# path = "src/bin/testapp.rs"
-# [[bin]]
-# name = "zinit-http"
-# path = "src/bin/zinit-http.rs"
-
+path = "src/main.rs"

Cargo.toml

@@ -2,6 +2,5 @@ FROM ubuntu:18.04
 
 RUN mkdir -p /etc/zinit
 ADD zinit /sbin/zinit
-# ADD zinit-http /sbin/zinit-http
 
 ENTRYPOINT ["/sbin/zinit", "init"] 

docker/Dockerfile

@@ -8,10 +8,12 @@ authors = ["ThreeFold Tech, https://github.com/threefoldtech"]
 
 [dependencies]
 anyhow = "1.0"
+async-trait = "0.1.88"
+jsonrpsee = { version = "0.24.9", features = ["server", "client", "macros"] }
+reth-ipc = { git = "https://github.com/paradigmxyz/reth", package = "reth-ipc" }
 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"
 
@@ -21,4 +23,4 @@ path = "examples/basic_usage.rs"
 
 [[example]]
 name = "http_client"
-path = "examples/http_client.rs"
+path = "examples/http_client.rs"

zinit-client/Cargo.toml

@@ -1,102 +1,50 @@
 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 = "test1234";
-
-    // Step 1: List existing services
-    println!("Listing all services before creating our test service:");
+    let client = Client::unix_socket("/var/run/zinit.sock").await?;
+    
+    // List all services
     let services = client.list().await?;
-
-    // Print all services
-    for (name, state) in &services {
-        println!("- {}: {}", name, state);
+    println!("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 'hello from test service'",
-        "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);
+    
+    // Get a specific service status
+    let service_name = "example-service";
+    match client.status(service_name).await {
+        Ok(status) => {
+            println!("\nService: {}", status.name);
+            println!("PID: {}", status.pid);
+            println!("State: {}", status.state);
+            println!("Target: {}", status.target);
+            println!("After:");
+            for (dep, state) in status.after {
+                println!("  {}: {}", dep, state);
+            }
+        },
+        Err(e) => eprintln!("Failed to get status: {}", e),
     }
-
-    // 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);
+    
+    // Try to start a service
+    match client.start(service_name).await {
+        Ok(_) => println!("\nService started successfully"),
+        Err(e) => eprintln!("Failed to start service: {}", e),
     }
-
-    // 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);
+    
+    // Get logs for the service
+    match client.logs(Some(service_name.to_string())).await {
+        Ok(logs) => {
+            println!("\nLogs:");
+            for log in logs {
+                println!("{}", log);
+            }
+        },
+        Err(e) => eprintln!("Failed to get logs: {}", e),
     }
-
+    
     Ok(())
 }

zinit-client/examples/basic_usage.rs

@@ -1,45 +1,75 @@
 use anyhow::Result;
+use serde_json::json;
 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...");
-
+    let client = Client::http("http://localhost:8080").await?;
+    
+    // Create a new service
+    let service_name = "example-http-service";
+    let service_config = json!({
+        "exec": "echo 'Hello from HTTP service'",
+        "oneshot": true,
+        "after": ["network"]
+    }).as_object().unwrap().clone();
+    
+    match client.create_service(service_name, service_config).await {
+        Ok(msg) => println!("Service created: {}", msg),
+        Err(e) => eprintln!("Failed to create service: {}", e),
+    }
+    
+    // Start the HTTP/RPC server on a specific address
+    match client.start_http_server("0.0.0.0:8081").await {
+        Ok(msg) => println!("HTTP server status: {}", msg),
+        Err(e) => eprintln!("Failed to start HTTP server: {}", e),
+    }
+    
     // 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");
-        }
+    let services = client.list().await?;
+    println!("\nServices:");
+    for (name, state) in services {
+        println!("{}: {}", name, state);
     }
-
+    
+    // Monitor the service
+    match client.monitor(service_name).await {
+        Ok(_) => println!("\nService is now monitored"),
+        Err(e) => eprintln!("Failed to monitor service: {}", e),
+    }
+    
+    // Start the service
+    match client.start(service_name).await {
+        Ok(_) => println!("Service started successfully"),
+        Err(e) => eprintln!("Failed to start service: {}", e),
+    }
+    
+    // Get logs
+    let logs = client.logs(Some(service_name.to_string())).await?;
+    println!("\nLogs:");
+    for log in logs {
+        println!("{}", log);
+    }
+    
+    // Clean up - forget the service
+    println!("\nCleaning up...");
+    match client.forget(service_name).await {
+        Ok(_) => println!("Service has been forgotten"),
+        Err(e) => eprintln!("Failed to forget service: {}", e),
+    }
+    
+    // Clean up - delete the service configuration
+    match client.delete_service(service_name).await {
+        Ok(msg) => println!("{}", msg),
+        Err(e) => eprintln!("Failed to delete service: {}", e),
+    }
+    
+    // Stop the HTTP/RPC server
+    match client.stop_http_server().await {
+        Ok(_) => println!("HTTP server stopped"),
+        Err(e) => eprintln!("Failed to stop HTTP server: {}", e),
+    }
+    
     Ok(())
 }