apply cargo fmt

Author: maximevanhees

src/app/api.rs

@@ -10,8 +10,8 @@ use serde_json::Value;
 use std::collections::HashMap;
 use std::sync::Arc;
 use tokio::sync::Mutex;
+use tower_http::cors::{AllowHeaders, AllowMethods};
 use tower_http::cors::{Any, CorsLayer};
-use tower_http::cors::{AllowMethods, AllowHeaders};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[serde(rename_all = "lowercase")]
@@ -83,7 +83,8 @@ impl Api {
         let middleware = tower::ServiceBuilder::new().layer(cors);
 
         // Create the JSON-RPC server with CORS support
-        let server_rpc = jsonrpsee::server::ServerBuilder::default().set_http_middleware(middleware)
+        let server_rpc = jsonrpsee::server::ServerBuilder::default()
+            .set_http_middleware(middleware)
             .build(socket_addr)
             .await?;
 

src/app/mod.rs

@@ -8,14 +8,14 @@ use reth_ipc::client::IpcClientBuilder;
 use rpc::ZinitLoggingApiClient;
 use rpc::ZinitServiceApiClient;
 use rpc::ZinitSystemApiClient;
-use std::net::ToSocketAddrs;
 use serde_yaml as encoder;
+use std::net::ToSocketAddrs;
 use std::path::{Path, PathBuf};
 use tokio::fs;
+use tokio::signal;
 use tokio::time;
 use tokio_stream::wrappers::ReceiverStream;
 use tokio_stream::Stream;
-use tokio::signal;
 
 fn logger(level: log::LevelFilter) -> Result<()> {
     let logger = fern::Dispatch::new()
@@ -175,7 +175,11 @@ pub async fn kill(socket: &str, name: String, signal: String) -> Result<()> {
     Ok(())
 }
 
-pub async fn logs(socket: &str, filter: Option<String>, follow: bool) -> Result<impl Stream<Item = String> + Unpin> {
+pub async fn logs(
+    socket: &str,
+    filter: Option<String>,
+    follow: bool,
+) -> Result<impl Stream<Item = String> + Unpin> {
     let client = IpcClientBuilder::default().build(socket.into()).await?;
     if let Some(ref filter) = filter {
         client.status(filter.clone()).await?;
@@ -204,7 +208,7 @@ pub async fn logs(socket: &str, filter: Option<String>, follow: bool) -> Result<
                 Some(Ok(log)) => {
                     if tx.send(log).await.is_err() {
                         let _ = logs_sub.unsubscribe().await;
-                        return
+                        return;
                     }
                 }
                 Some(Err(e)) => {
@@ -222,7 +226,8 @@ pub async fn logs(socket: &str, filter: Option<String>, follow: bool) -> Result<
 /// Start an HTTP/RPC proxy server for the Zinit API at the specified address
 pub async fn proxy(sock: &str, address: String) -> Result<()> {
     // Parse the socket address
-    let _socket_addr = address.to_socket_addrs()
+    let _socket_addr = address
+        .to_socket_addrs()
         .context("Failed to parse socket address")?
         .next()
         .context("No valid socket address found")?;
@@ -232,20 +237,20 @@ pub async fn proxy(sock: &str, address: String) -> Result<()> {
 
     // Connect to the existing Zinit daemon through the Unix socket
     let client = IpcClientBuilder::default().build(sock.into()).await?;
-    
+
     // Issue an RPC call to start the HTTP server on the specified address
     let result = client.start_http_server(address.clone()).await?;
-    
+
     println!("{}", result);
     println!("Press Ctrl+C to stop");
-    
+
     // Wait for Ctrl+C to shutdown
     signal::ctrl_c().await?;
-    
+
     // Shutdown the HTTP server
     client.stop_http_server().await?;
-    
+
     println!("HTTP/RPC server stopped");
-    
+
     Ok(())
-}
+}

src/app/rpc.rs

@@ -1,5 +1,5 @@
-use crate::zinit::config;
 use crate::app::api::Status;
+use crate::zinit::config;
 use async_trait::async_trait;
 use jsonrpsee::core::{RpcResult, SubscriptionResult};
 use jsonrpsee::proc_macros::rpc;
@@ -12,7 +12,6 @@ use tokio_stream::StreamExt;
 
 use super::api::Api;
 
-
 // Custom error codes for Zinit
 const SERVICE_NOT_FOUND: i32 = -32000;
 const SERVICE_IS_UP: i32 = -32002;
@@ -286,11 +285,11 @@ pub trait ZinitSystemApi {
     /// Initiate system reboot process.
     #[method(name = "reboot")]
     async fn reboot(&self) -> RpcResult<()>;
-    
+
     /// Start an HTTP/RPC server at the specified address
     #[method(name = "start_http_server")]
     async fn start_http_server(&self, address: String) -> RpcResult<String>;
-    
+
     /// Stop the HTTP/RPC server if running
     #[method(name = "stop_http_server")]
     async fn stop_http_server(&self) -> RpcResult<()>;
@@ -311,20 +310,20 @@ impl ZinitSystemApiServer for Api {
             .await
             .map_err(|_| ErrorObjectOwned::from(ErrorCode::InternalError))
     }
-    
+
     async fn start_http_server(&self, address: String) -> RpcResult<String> {
         // Call the method from the API implementation
         match crate::app::api::Api::start_http_server(self, address).await {
             Ok(result) => Ok(result),
-            Err(_) => Err(ErrorObjectOwned::from(ErrorCode::InternalError))
+            Err(_) => Err(ErrorObjectOwned::from(ErrorCode::InternalError)),
         }
     }
-    
+
     async fn stop_http_server(&self) -> RpcResult<()> {
         // Call the method from the API implementation
         match crate::app::api::Api::stop_http_server(self).await {
             Ok(_) => Ok(()),
-            Err(_) => Err(ErrorObjectOwned::from(ErrorCode::InternalError))
+            Err(_) => Err(ErrorObjectOwned::from(ErrorCode::InternalError)),
         }
     }
 }
@@ -370,7 +369,7 @@ impl ZinitLoggingApiServer for Api {
     ) -> SubscriptionResult {
         let sink = sink.accept().await?;
         let filter = name.map(|n| format!("{n}:"));
-        let mut stream = 
+        let mut stream =
             tokio_stream::wrappers::ReceiverStream::new(self.zinit.logs(false, true).await)
                 .filter_map(|l| {
                     if let Some(ref filter) = filter {
@@ -383,10 +382,7 @@ impl ZinitLoggingApiServer for Api {
                         Some(l.to_string())
                     }
                 });
-        while let Some(log) = stream
-                .next()
-                .await
-        {
+        while let Some(log) = stream.next().await {
             if sink.send(log.into()).await.is_err() {
                 break;
             }

src/bin/testapp.rs

@@ -1,9 +1,8 @@
 #[tokio::main]
-async fn main () {
+async fn main() {
     println!("hello from testapp");
 }
 
-
 // extern crate zinit;
 
 // use anyhow::Result;

zinit-client/examples/basic_usage.rs

@@ -8,48 +8,51 @@ use zinit_client::Client;
 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 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 'hello from test service'",
         "oneshot": false,
         "log": "stdout"
-    }).as_object().unwrap().clone();
-    
+    })
+    .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?;
@@ -61,39 +64,39 @@ async fn main() -> Result<()> {
     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/http_client.rs

@@ -5,9 +5,9 @@ use zinit_client::Client;
 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 {
@@ -18,7 +18,7 @@ async fn main() -> Result<()> {
                 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);
@@ -29,17 +29,17 @@ async fn main() -> Result<()> {
                             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(())
-}
+}

zinit-client/src/lib.rs

@@ -112,7 +112,11 @@ impl Client {
     }
 
     /// Send a JSON-RPC request and return the result
-    async fn jsonrpc_request(&self, method: &str, params: Option<Value>) -> Result<Value, ClientError> {
+    async fn jsonrpc_request(
+        &self,
+        method: &str,
+        params: Option<Value>,
+    ) -> Result<Value, ClientError> {
         // Get a unique ID for this request
         let id = self.next_id.fetch_add(1, Ordering::SeqCst);
 
@@ -124,7 +128,9 @@ impl Client {
         };
 
         match &self.transport {
-            Transport::UnixSocket(socket_path) => self.unix_socket_request(&request, socket_path).await,
+            Transport::UnixSocket(socket_path) => {
+                self.unix_socket_request(&request, socket_path).await
+            }
             Transport::Http(url) => self.http_request(&request, url).await,
         }
     }
@@ -173,8 +179,8 @@ impl Client {
         }
 
         // Convert to string and trim the trailing newline
-        let data = String::from_utf8(buffer)
-            .map_err(|e| ClientError::InvalidResponse(e.to_string()))?;
+        let data =
+            String::from_utf8(buffer).map_err(|e| ClientError::InvalidResponse(e.to_string()))?;
         let data = data.trim_end();
 
         // Parse the JSON-RPC response
@@ -315,7 +321,8 @@ impl Client {
             "name": name.as_ref()
         });
 
-        self.jsonrpc_request("service.monitor", Some(params)).await?;
+        self.jsonrpc_request("service.monitor", Some(params))
+            .await?;
         Ok(())
     }
 
@@ -386,4 +393,4 @@ impl Client {
 #[cfg(test)]
 mod tests {
     // Tests would go here
-}
+}