Fix lint warnings

Signed-off-by: Guvenc Gulce <[email protected]>

Author: guvenc

Cargo.toml

@@ -12,6 +12,9 @@ members = [
 ]
 resolver = "2"
 
+[workspace.lints.clippy]
+uninlined_format_args = "warn"
+
 [workspace.package]
 version = "0.5.0"
 edition = "2021"

cli/Cargo.toml

@@ -4,6 +4,9 @@ version.workspace = true
 edition.workspace = true
 description = "A gRPC CLI for the FeOS control plane"
 
+[lints]
+workspace = true
+
 [dependencies]
 # Workspace dependencies
 feos-proto = { workspace = true }

cli/src/container_commands.rs

@@ -81,7 +81,7 @@ pub enum ContainerCommand {
 fn parse_key_val(s: &str) -> Result<(String, String), String> {
     s.split_once('=')
         .map(|(key, value)| (key.to_string(), value.to_string()))
-        .ok_or_else(|| format!("invalid KEY=value format: {}", s))
+        .ok_or_else(|| format!("invalid KEY=value format: {s}"))
 }
 
 pub async fn handle_container_command(args: ContainerArgs) -> Result<()> {
@@ -113,7 +113,7 @@ async fn create_container(
     cmd: Vec<String>,
     env: Vec<(String, String)>,
 ) -> Result<()> {
-    println!("Requesting container creation with image: {}...", image_ref);
+    println!("Requesting container creation with image: {image_ref}...");
 
     let config = ContainerConfig {
         image_ref,
@@ -140,23 +140,23 @@ async fn create_container(
 }
 
 async fn start_container(client: &mut ContainerServiceClient<Channel>, id: String) -> Result<()> {
-    println!("Requesting to start container: {}...", id);
+    println!("Requesting to start container: {id}...");
     let request = StartContainerRequest {
         container_id: id.clone(),
     };
     client.start_container(request).await?;
-    println!("Start request sent for container: {}", id);
+    println!("Start request sent for container: {id}");
     Ok(())
 }
 
 async fn stop_container(client: &mut ContainerServiceClient<Channel>, id: String) -> Result<()> {
-    println!("Requesting to stop container: {}...", id);
+    println!("Requesting to stop container: {id}...");
     let request = StopContainerRequest {
         container_id: id.clone(),
         ..Default::default()
     };
     client.stop_container(request).await?;
-    println!("Stop request sent for container: {}", id);
+    println!("Stop request sent for container: {id}");
     Ok(())
 }
 
@@ -169,16 +169,16 @@ async fn get_container_info(
     };
     let response = client.get_container(request).await?.into_inner();
 
-    println!("Container Info for: {}", id);
+    println!("Container Info for: {id}");
     println!(
         "  State: {:?}",
         ContainerState::try_from(response.state).unwrap_or(ContainerState::Unspecified)
     );
     if let Some(pid) = response.pid {
-        println!("  PID: {}", pid);
+        println!("  PID: {pid}");
     }
     if let Some(exit_code) = response.exit_code {
-        println!("  Exit Code: {}", exit_code);
+        println!("  Exit Code: {exit_code}");
     }
     if let Some(config) = response.config {
         println!("  Config:");
@@ -223,11 +223,11 @@ async fn list_containers(client: &mut ContainerServiceClient<Channel>) -> Result
 }
 
 async fn delete_container(client: &mut ContainerServiceClient<Channel>, id: String) -> Result<()> {
-    println!("Requesting to delete container: {}...", id);
+    println!("Requesting to delete container: {id}...");
     let request = DeleteContainerRequest {
         container_id: id.clone(),
     };
     client.delete_container(request).await?;
-    println!("Successfully deleted container: {}", id);
+    println!("Successfully deleted container: {id}");
     Ok(())
 }

feos/Cargo.toml

@@ -3,6 +3,9 @@ name = "feos"
 version.workspace = true
 edition.workspace = true
 
+[lints]
+workspace = true
+
 [[bin]]
 name = "feos"
 path = "src/main.rs"

feos/proto/Cargo.toml

@@ -3,6 +3,9 @@ name = "feos-proto"
 version.workspace = true
 edition.workspace = true
 
+[lints]
+workspace = true
+
 [lib]
 path = "src/lib.rs"
 

feos/services/container-service/Cargo.toml

@@ -3,6 +3,9 @@ name = "container-service"
 version.workspace = true
 edition.workspace = true
 
+[lints]
+workspace = true
+
 [dependencies]
 feos-proto = { workspace = true }
 image-service = { path = "../image-service" }

feos/services/container-service/src/dispatcher.rs

@@ -86,7 +86,7 @@ impl Dispatcher {
             let adapter = self.adapter.clone();
             tokio::spawn(async move {
                 if let Err(e) = Self::handle_command(cmd, repo, adapter).await {
-                    warn!("Dispatcher: Error handling command: {}", e);
+                    warn!("Dispatcher: Error handling command: {e}");
                 }
             });
         }
@@ -102,7 +102,7 @@ impl Dispatcher {
         })?;
 
         repo.get_container(container_id).await?.ok_or_else(|| {
-            ContainerServiceError::InvalidArgument(format!("Container '{}' not found", id_str))
+            ContainerServiceError::InvalidArgument(format!("Container '{id_str}' not found"))
         })
     }
 
@@ -140,7 +140,7 @@ impl Dispatcher {
 
                 let image_uuid_str = initiate_image_pull(&image_ref).await?;
                 let image_uuid = Uuid::parse_str(&image_uuid_str).map_err(|e| {
-                    ContainerServiceError::ImageService(format!("Invalid image UUID: {}", e))
+                    ContainerServiceError::ImageService(format!("Invalid image UUID: {e}"))
                 })?;
 
                 let record = crate::persistence::ContainerRecord {

feos/services/container-service/src/runtime/adapter.rs

@@ -203,9 +203,9 @@ impl ContainerAdapter {
                     OciLinuxNamespace {
                         typ: "mount".to_string(),
                     },
-                   // OciLinuxNamespace {
-                   //     typ: "network".to_string(),
-                   // },
+                    // OciLinuxNamespace {
+                    //     typ: "network".to_string(),
+                    // },
                 ],
             },
         };
@@ -223,24 +223,18 @@ impl ContainerAdapter {
         container_id: &str,
         bundle_path: &Path,
     ) -> Result<i64, AdapterError> {
-        info!("Adapter: Rewriting OCI spec for container {}", container_id);
+        info!("Adapter: Rewriting OCI spec for container {container_id}");
         Self::generate_runtime_spec(bundle_path).await?;
 
-        info!(
-            "Adapter: Connecting to TaskService for container {}",
-            container_id
-        );
+        info!("Adapter: Connecting to TaskService for container {container_id}");
         let mut task_client = Self::get_task_service_client().await?;
 
         let bundle_path_str = bundle_path
             .to_str()
             .ok_or_else(|| AdapterError::Internal("Bundle path is not valid UTF-8".to_string()))?
             .to_string();
 
-        info!(
-            "Adapter: Calling Create RPC on TaskService for container {}",
-            container_id
-        );
+        info!("Adapter: Calling Create RPC on TaskService for container {container_id}");
         let request = CreateRequest {
             container_id: container_id.to_string(),
             bundle_path: bundle_path_str,
@@ -252,10 +246,7 @@ impl ContainerAdapter {
         let response = task_client.create(request).await?;
 
         let pid = response.into_inner().pid;
-        info!(
-            "Adapter: TaskService created container {} with PID {}",
-            container_id, pid
-        );
+        info!("Adapter: TaskService created container {container_id} with PID {pid}");
 
         Ok(pid)
     }

feos/services/container-service/src/worker.rs

@@ -137,7 +137,7 @@ pub async fn handle_create_container(
             }
         }
         Err(e) => {
-            let error_msg = format!("Adapter failed to create container: {}", e);
+            let error_msg = format!("Adapter failed to create container: {e}");
             error!("ContainerWorker ({container_id}): {error_msg}");
             if let Err(e) = repository.delete_container(container_id).await {
                 warn!("Failed to cleanup DB record for failed creation of {container_id}: {e}");
@@ -157,22 +157,22 @@ pub async fn handle_start_container(
 
     match result {
         Ok(_) => {
-            info!("Worker: Start command sent for container {}", id_str);
+            info!("Worker: Start command sent for container {id_str}");
             let container_id = Uuid::parse_str(&id_str).unwrap();
             if let Err(e) = repository
                 .update_container_state(container_id, ContainerState::Running)
                 .await
             {
                 let err = ContainerServiceError::Persistence(e);
-                error!("Worker: {}", err);
+                error!("Worker: {err}");
                 let _ = responder.send(Err(err));
                 return;
             }
             let _ = responder.send(Ok(StartContainerResponse {}));
         }
         Err(e) => {
             let err = ContainerServiceError::Adapter(e.to_string());
-            error!("Worker: {}", err);
+            error!("Worker: {err}");
             let _ = responder.send(Err(err));
         }
     }
@@ -190,22 +190,22 @@ pub async fn handle_stop_container(
 
     match result {
         Ok(_) => {
-            info!("Worker: Stop command sent for container {}", id_str);
+            info!("Worker: Stop command sent for container {id_str}");
             let container_id = Uuid::parse_str(&id_str).unwrap();
             if let Err(e) = repository
                 .update_container_state(container_id, ContainerState::Stopped)
                 .await
             {
                 let err = ContainerServiceError::Persistence(e);
-                error!("Worker: {}", err);
+                error!("Worker: {err}");
                 let _ = responder.send(Err(err));
                 return;
             }
             let _ = responder.send(Ok(StopContainerResponse {}));
         }
         Err(e) => {
             let err = ContainerServiceError::Adapter(e.to_string());
-            error!("Worker: {}", err);
+            error!("Worker: {err}");
             let _ = responder.send(Err(err));
         }
     }
@@ -222,19 +222,19 @@ pub async fn handle_delete_container(
 
     match result {
         Ok(_) => {
-            info!("Worker: Delete command sent for container {}", id_str);
+            info!("Worker: Delete command sent for container {id_str}");
             let container_id = Uuid::parse_str(&id_str).unwrap();
             if let Err(e) = repository.delete_container(container_id).await {
                 let err = ContainerServiceError::Persistence(e);
-                error!("Worker: {}", err);
+                error!("Worker: {err}");
                 let _ = responder.send(Err(err));
                 return;
             }
             let _ = responder.send(Ok(DeleteContainerResponse {}));
         }
         Err(e) => {
             let err = ContainerServiceError::Adapter(e.to_string());
-            error!("Worker: {}", err);
+            error!("Worker: {err}");
             let _ = responder.send(Err(err));
         }
     }

feos/services/host-service/Cargo.toml

@@ -3,6 +3,9 @@ name = "host-service"
 version.workspace = true
 edition.workspace = true
 
+[lints]
+workspace = true
+
 [dependencies]
 feos-utils = { path = "../../utils" }
 feos-proto = { workspace = true }