applying cargo formatting

Author: maximevanhees

zinit-client/examples/basic_usage.rs

@@ -5,14 +5,14 @@ use zinit_client::Client;
 async fn main() -> Result<()> {
     // Create a client using Unix socket transport
     let client = Client::unix_socket("/var/run/zinit.sock").await?;
-    
+
     // List all services
     let services = client.list().await?;
     println!("Services:");
     for (name, state) in services {
         println!("{}: {}", name, state);
     }
-    
+
     // Get a specific service status
     let service_name = "example-service";
     match client.status(service_name).await {
@@ -25,26 +25,26 @@ async fn main() -> Result<()> {
             for (dep, state) in status.after {
                 println!("  {}: {}", dep, state);
             }
-        },
+        }
         Err(e) => eprintln!("Failed to get status: {}", e),
     }
-    
+
     // Try to start a service
     match client.start(service_name).await {
         Ok(_) => println!("\nService started successfully"),
         Err(e) => eprintln!("Failed to start service: {}", e),
     }
-    
+
     // 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/http_client.rs

@@ -6,70 +6,73 @@ use zinit_client::Client;
 async fn main() -> Result<()> {
     // Create a client using HTTP transport
     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();
-    
+    })
+    .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
     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(())
 }