clippy fix

Signed-off-by: Tuan Anh Tran <[email protected]>

Author: tuananh

src/oci.rs

@@ -62,8 +62,7 @@ fn build_auth(reference: &Reference) -> RegistryAuth {
         Err(CredentialRetrievalError::NoCredentialConfigured) => RegistryAuth::Anonymous,
         Err(e) => {
             log::info!(
-                "Error retrieving docker credentials: {}. Using anonymous auth",
-                e
+                "Error retrieving docker credentials: {e}. Using anonymous auth"
             );
             RegistryAuth::Anonymous
         }
@@ -87,7 +86,7 @@ async fn setup_trust_repository(cli: &Cli) -> Result<Box<dyn TrustRoot>, anyhow:
         match SigstoreTrustRoot::new(None).await {
             Ok(repo) => return Ok(Box::new(repo)),
             Err(e) => {
-                log::warn!("Failed to initialize TUF trust repository: {}", e);
+                log::warn!("Failed to initialize TUF trust repository: {e}");
                 log::info!("Falling back to manual trust repository");
             }
         }
@@ -104,10 +103,10 @@ async fn setup_trust_repository(cli: &Cli) -> Result<Box<dyn TrustRoot>, anyhow:
                     log::info!("Added Rekor public key");
                     data.rekor_keys.push(content);
                 }
-                Err(e) => log::warn!("Failed to read Rekor public keys file: {}", e),
+                Err(e) => log::warn!("Failed to read Rekor public keys file: {e}"),
             }
         } else {
-            log::warn!("Rekor public keys file not found: {:?}", rekor_keys_path);
+            log::warn!("Rekor public keys file not found: {rekor_keys_path:?}");
         }
     }
 
@@ -126,15 +125,14 @@ async fn setup_trust_repository(cli: &Cli) -> Result<Box<dyn TrustRoot>, anyhow:
                             log::info!("Added Fulcio certificate");
                             data.fulcio_certs.push(cert);
                         }
-                        Err(e) => log::warn!("Failed to parse Fulcio certificate: {}", e),
+                        Err(e) => log::warn!("Failed to parse Fulcio certificate: {e}"),
                     }
                 }
-                Err(e) => log::warn!("Failed to read Fulcio certificates file: {}", e),
+                Err(e) => log::warn!("Failed to read Fulcio certificates file: {e}"),
             }
         } else {
             log::warn!(
-                "Fulcio certificates file not found: {:?}",
-                fulcio_certs_path
+                "Fulcio certificates file not found: {fulcio_certs_path:?}"
             );
         }
     }
@@ -143,7 +141,7 @@ async fn setup_trust_repository(cli: &Cli) -> Result<Box<dyn TrustRoot>, anyhow:
 }
 
 async fn verify_image_signature(cli: &Cli, image_reference: &str) -> Result<bool, anyhow::Error> {
-    log::info!("Verifying signature for {}", image_reference);
+    log::info!("Verifying signature for {image_reference}");
 
     // Set up the trust repository based on CLI arguments
     let repo = setup_trust_repository(cli).await?;
@@ -175,7 +173,7 @@ async fn verify_image_signature(cli: &Cli, image_reference: &str) -> Result<bool
         match client.triangulate(&image_ref, auth).await {
             Ok((sig_image, digest)) => (sig_image, digest),
             Err(e) => {
-                log::warn!("Failed to triangulate image: {}", e);
+                log::warn!("Failed to triangulate image: {e}");
                 return Ok(false); // No signatures found
             }
         };
@@ -187,13 +185,13 @@ async fn verify_image_signature(cli: &Cli, image_reference: &str) -> Result<bool
     {
         Ok(layers) => layers,
         Err(e) => {
-            log::warn!("Failed to get trusted signature layers: {}", e);
+            log::warn!("Failed to get trusted signature layers: {e}");
             return Ok(false);
         }
     };
 
     if signature_layers.is_empty() {
-        log::warn!("No valid signatures found for {}", image_reference);
+        log::warn!("No valid signatures found for {image_reference}");
         return Ok(false);
     }
 
@@ -229,16 +227,14 @@ async fn verify_image_signature(cli: &Cli, image_reference: &str) -> Result<bool
     // Verify the constraints
     match verify_constraints(&signature_layers, verification_constraints.iter()) {
         Ok(()) => {
-            log::info!("Signature verification successful for {}", image_reference);
+            log::info!("Signature verification successful for {image_reference}");
             Ok(true)
         }
         Err(SigstoreVerifyConstraintsError {
             unsatisfied_constraints,
         }) => {
             log::warn!(
-                "Signature verification failed for {}: {:?}",
-                image_reference,
-                unsatisfied_constraints
+                "Signature verification failed for {image_reference}: {unsatisfied_constraints:?}"
             );
             Ok(false)
         }
@@ -253,14 +249,12 @@ pub async fn pull_and_extract_oci_image(
 ) -> Result<(), Box<dyn std::error::Error>> {
     if Path::new(local_output_path).exists() {
         log::info!(
-            "Plugin {} already cached at: {}. Skipping downloading.",
-            image_reference,
-            local_output_path
+            "Plugin {image_reference} already cached at: {local_output_path}. Skipping downloading."
         );
         return Ok(());
     }
 
-    log::info!("Pulling {} ...", image_reference);
+    log::info!("Pulling {image_reference} ...");
 
     let client_config = oci_client::client::ClientConfig::default();
     let client = Client::new(client_config);
@@ -270,23 +264,22 @@ pub async fn pull_and_extract_oci_image(
 
     // Verify the image signature if it's an OCI image and verification is enabled
     if !cli.insecure_skip_signature {
-        log::info!("Signature verification enabled for {}", image_reference);
+        log::info!("Signature verification enabled for {image_reference}");
         match verify_image_signature(cli, image_reference).await {
             Ok(verified) => {
                 if !verified {
                     return Err(format!(
-                        "No valid signatures found for the image {}",
-                        image_reference
+                        "No valid signatures found for the image {image_reference}"
                     )
                     .into());
                 }
             }
             Err(e) => {
-                return Err(format!("Image signature verification failed: {}", e).into());
+                return Err(format!("Image signature verification failed: {e}").into());
             }
         }
     } else {
-        log::warn!("Signature verification disabled for {}", image_reference);
+        log::warn!("Signature verification disabled for {image_reference}");
     }
 
     // Accept both OCI and Docker manifest types
@@ -327,12 +320,12 @@ pub async fn pull_and_extract_oci_image(
                             let mut content = Vec::new();
                             entry.read_to_end(&mut content)?;
                             fs::write(local_output_path, content)?;
-                            log::info!("Successfully extracted to: {}", local_output_path);
+                            log::info!("Successfully extracted to: {local_output_path}");
                             return Ok(());
                         }
                     }
                 }
-                Err(e) => log::info!("Error during extraction: {}", e),
+                Err(e) => log::info!("Error during extraction: {e}"),
             }
         }
     }

src/plugins.rs

@@ -71,7 +71,7 @@ impl PluginService {
                     .pull_and_extract(image_reference, target_file_path, local_output_path)
                     .await
                 {
-                    log::error!("Error pulling oci plugin: {}", e);
+                    log::error!("Error pulling oci plugin: {e}");
                     return Err(anyhow::anyhow!("Failed to pull OCI plugin: {}", e));
                 }
                 log::info!(
@@ -85,7 +85,7 @@ impl PluginService {
             };
             let mut manifest = Manifest::new([Wasm::data(wasm_content)]);
             if let Some(runtime_cfg) = &plugin_cfg.runtime_config {
-                log::info!("runtime_cfg: {:?}", runtime_cfg);
+                log::info!("runtime_cfg: {runtime_cfg:?}");
                 if let Some(hosts) = &runtime_cfg.allowed_hosts {
                     for host in hosts {
                         manifest = manifest.with_allowed_host(host);
@@ -114,9 +114,7 @@ impl PluginService {
                         }
                         Err(e) => {
                             log::error!(
-                                "Failed to parse memory_limit '{}': {}. Using default memory limit.",
-                                memory_limit,
-                                e
+                                "Failed to parse memory_limit '{memory_limit}': {e}. Using default memory limit."
                             );
                         }
                     }
@@ -171,7 +169,7 @@ impl PluginService {
                 .write()
                 .await
                 .insert(plugin_name.clone(), plugin);
-            log::info!("Loaded plugin {}", plugin_name);
+            log::info!("Loaded plugin {plugin_name}");
         }
         Ok(())
     }
@@ -218,9 +216,7 @@ impl ServerHandler for PluginService {
                             // Strip the prefix to get the original tool name
                             original_name = tool_name_str[tool_name_prefix.len()..].to_string();
                             log::info!(
-                                "Found tool with prefix, stripping for internal call: {} -> {}",
-                                tool_name_str,
-                                original_name
+                                "Found tool with prefix, stripping for internal call: {tool_name_str} -> {original_name}"
                             );
                             break;
                         }
@@ -236,9 +232,7 @@ impl ServerHandler for PluginService {
                             // Strip the prefix to get the original tool name
                             original_name = tool_name_str[tool_name_prefix.len()..].to_string();
                             log::info!(
-                                "Stripping prefix from tool: {} -> {}",
-                                tool_name_str,
-                                original_name
+                                "Stripping prefix from tool: {tool_name_str} -> {original_name}"
                             );
 
                             // Check if the original tool name is in the cache
@@ -279,18 +273,17 @@ impl ServerHandler for PluginService {
                     Ok(Ok(result)) => match serde_json::from_str::<CallToolResult>(&result) {
                         Ok(parsed) => Ok(parsed),
                         Err(e) => Err(McpError::internal_error(
-                            format!("Failed to deserialize data: {}", e),
+                            format!("Failed to deserialize data: {e}"),
                             None,
                         )),
                     },
                     Ok(Err(e)) => Err(McpError::internal_error(
-                        format!("Failed to execute plugin {}: {}", plugin_name_clone, e),
+                        format!("Failed to execute plugin {plugin_name_clone}: {e}"),
                         None,
                     )),
                     Err(e) => Err(McpError::internal_error(
                         format!(
-                            "Failed to spawn blocking task for plugin {}: {}",
-                            plugin_name_clone, e
+                            "Failed to spawn blocking task for plugin {plugin_name_clone}: {e}"
                         ),
                         None,
                     )),
@@ -347,11 +340,9 @@ impl ServerHandler for PluginService {
                                 if let Some(runtime_cfg) = &plugin_cfg.runtime_config {
                                     if let Some(tool_name_prefix) = &runtime_cfg.tool_name_prefix {
                                         let prefixed_name =
-                                            format!("{}{}", tool_name_prefix, original_name);
+                                            format!("{tool_name_prefix}{original_name}");
                                         log::info!(
-                                            "Adding prefix to tool: {} -> {}",
-                                            original_name,
-                                            prefixed_name
+                                            "Adding prefix to tool: {original_name} -> {prefixed_name}"
                                         );
 
                                         // Store both the original and prefixed tool names in the cache
@@ -371,10 +362,10 @@ impl ServerHandler for PluginService {
                         }
                     }
                     Ok(Err(e)) => {
-                        log::error!("tool {} describe() error: {}", plugin_name, e);
+                        log::error!("tool {plugin_name} describe() error: {e}");
                     }
                     Err(e) => {
-                        log::error!("tool {} spawn_blocking error: {}", plugin_name, e);
+                        log::error!("tool {plugin_name} spawn_blocking error: {e}");
                     }
                 }
             }