fix clippy warnings

Author: say-paul

src/lib/greenboot.rs

@@ -21,9 +21,9 @@ pub fn run_diagnostics(skipped: Vec<String>) -> Result<Vec<String>> {
 
     // Run required checks
     for path in GREENBOOT_INSTALL_PATHS {
-        let greenboot_required_path = format!("{}/check/required.d/", path);
+        let greenboot_required_path = format!("{path}/check/required.d/");
         if !Path::new(&greenboot_required_path).is_dir() {
-            log::warn!("skipping test as {} is not a dir", greenboot_required_path);
+            log::warn!("skipping test as {greenboot_required_path} is not a dir");
             continue;
         }
         path_exists = true;
@@ -43,7 +43,7 @@ pub fn run_diagnostics(skipped: Vec<String>) -> Result<Vec<String>> {
 
     // Run wanted checks
     for path in GREENBOOT_INSTALL_PATHS {
-        let greenboot_wanted_path = format!("{}/check/wanted.d/", path);
+        let greenboot_wanted_path = format!("{path}/check/wanted.d/");
         let result = run_scripts("wanted", &greenboot_wanted_path, Some(&skipped));
         all_skipped.extend(result.skipped);
 
@@ -61,8 +61,7 @@ pub fn run_diagnostics(skipped: Vec<String>) -> Result<Vec<String>> {
 
     if !missing_disabled.is_empty() {
         log::warn!(
-            "The following disabled scripts were not found in any directory: {:?}",
-            missing_disabled
+            "The following disabled scripts were not found in any directory: {missing_disabled:?}"
         );
     }
 
@@ -74,7 +73,7 @@ pub fn run_red() -> Vec<Box<dyn Error>> {
     let mut errors = Vec::new();
 
     for path in GREENBOOT_INSTALL_PATHS {
-        let red_path = format!("{}/red.d/", path);
+        let red_path = format!("{path}/red.d/");
         let result = run_scripts("red", &red_path, None); // Pass None for disabled scripts
         errors.extend(result.errors);
     }
@@ -87,7 +86,7 @@ pub fn run_green() -> Vec<Box<dyn Error>> {
     let mut errors = Vec::new();
 
     for path in GREENBOOT_INSTALL_PATHS {
-        let green_path = format!("{}/green.d/", path);
+        let green_path = format!("{path}/green.d/");
         let result = run_scripts("green", &green_path, None); // Pass None for disabled scripts
         errors.extend(result.errors);
     }
@@ -106,7 +105,7 @@ fn run_scripts(name: &str, path: &str, disabled_scripts: Option<&[String]>) -> S
         skipped: Vec::new(),
     };
 
-    let entries = match glob(&format!("{}*", path)) {
+    let entries = match glob(&format!("{path}*")) {
         Ok(e) => {
             let valid: Vec<_> = e
                 .filter_map(Result::ok)
@@ -139,7 +138,7 @@ fn run_scripts(name: &str, path: &str, disabled_scripts: Option<&[String]>) -> S
         // Check if script/binary should be skipped
         if let Some(disabled) = disabled_scripts {
             if disabled.contains(&file_name.to_string()) {
-                log::info!("Skipping disabled script: {}", file_name);
+                log::info!("Skipping disabled script: {file_name}");
                 result.skipped.push(file_name.to_string());
                 continue;
             }

src/lib/handler.rs

@@ -61,13 +61,12 @@ pub fn handle_rollback() -> Result<()> {
             log::info!("Greenboot will now attempt to rollback to a previous deployment.");
             if let Some(deployment_cmd) = detect_os_deployment() {
                 log::info!(
-                    "Deployment manager '{}' detected, attempting rollback.",
-                    deployment_cmd
+                    "Deployment manager '{deployment_cmd}' detected, attempting rollback."
                 );
                 let status = Command::new(deployment_cmd)
                     .arg("rollback")
                     .status()
-                    .context(format!("Failed to execute '{} rollback'", deployment_cmd))?;
+                    .context(format!("Failed to execute '{deployment_cmd} rollback'"))?;
 
                 if !status.success() {
                     bail!(

src/lib/mount.rs

@@ -42,17 +42,15 @@ pub fn remount_boot_ro(mounts_path: &Path) -> Result<(), MountError> {
                     } else {
                         let error_message = String::from_utf8_lossy(&output.stderr);
                         warn!(
-                            "Failed to remount /boot as RO using shell: {}",
-                            error_message
+                            "Failed to remount /boot as RO using shell: {error_message}"
                         );
                         Err(MountError::RemountFailed(error_message.to_string()))
                     }
                 }
                 Err(e) => {
-                    warn!("Failed to execute mount command: {}", e);
+                    warn!("Failed to execute mount command: {e}");
                     Err(MountError::RemountFailed(format!(
-                        "Failed to execute mount: {}",
-                        e
+                        "Failed to execute mount: {e}"
                     )))
                 }
             }
@@ -82,17 +80,15 @@ pub fn remount_boot_rw(mounts_path: &Path) -> Result<(), MountError> {
                     } else {
                         let error_message = String::from_utf8_lossy(&output.stderr);
                         warn!(
-                            "Failed to remount /boot as RW using shell: {}",
-                            error_message
+                            "Failed to remount /boot as RW using shell: {error_message}"
                         );
                         Err(MountError::RemountFailed(error_message.to_string()))
                     }
                 }
                 Err(e) => {
-                    warn!("Failed to execute mount command: {}", e);
+                    warn!("Failed to execute mount command: {e}");
                     Err(MountError::RemountFailed(format!(
-                        "Failed to execute mount: {}",
-                        e
+                        "Failed to execute mount: {e}"
                     )))
                 }
             }

src/main.rs

@@ -135,7 +135,7 @@ fn check_previous_rollback() -> Result<bool> {
     // Check for specific success indicators
     let success = journal_output.contains("Rollback successful");
 
-    log::debug!("Rollback detection result: {}", success);
+    log::debug!("Rollback detection result: {success}");
     Ok(success)
 }
 
@@ -168,8 +168,7 @@ fn health_check() -> Result<()> {
         }
         Err(e) => {
             log::warn!(
-                "Failed to check previous rollback status: {}. Defaulting to false.",
-                e
+                "Failed to check previous rollback status: {e}. Defaulting to false."
             );
             false
         }
@@ -194,7 +193,7 @@ fn health_check() -> Result<()> {
                 "Greenboot healthcheck passed - status is GREEN",
                 previous_rollback,
             )?)
-            .unwrap_or_else(|e| log::error!("cannot set motd: {}", e));
+            .unwrap_or_else(|e| log::error!("cannot set motd: {e}"));
             set_boot_status(true, GRUB_PATH, MOUNT_INFO_PATH)?;
             Ok(())
         }
@@ -205,18 +204,18 @@ fn health_check() -> Result<()> {
                 "Greenboot healthcheck failed - status is RED",
                 previous_rollback,
             )?)
-            .unwrap_or_else(|e| log::error!("cannot set motd: {}", e));
+            .unwrap_or_else(|e| log::error!("cannot set motd: {e}"));
             let errors = run_red();
             if !errors.is_empty() {
                 log::error!("There is a problem with red script runner");
                 errors.iter().for_each(|e| log::error!("{e}"));
             }
 
             set_boot_status(false, GRUB_PATH, MOUNT_INFO_PATH)
-                .unwrap_or_else(|e| log::error!("cannot set boot_status: {}", e));
+                .unwrap_or_else(|e| log::error!("cannot set boot_status: {e}"));
             set_boot_counter(config.max_reboot, GRUB_PATH, MOUNT_INFO_PATH)
-                .unwrap_or_else(|e| log::error!("cannot set boot_counter: {}", e));
-            handle_reboot(false).unwrap_or_else(|e| log::error!("cannot reboot: {}", e));
+                .unwrap_or_else(|e| log::error!("cannot set boot_counter: {e}"));
+            handle_reboot(false).unwrap_or_else(|e| log::error!("cannot reboot: {e}"));
             bail!("greenboot healthcheck failed")
         }
     }
@@ -239,7 +238,7 @@ fn trigger_rollback() -> Result<()> {
 // This function parses a string expected in bash-array format like
 // `( "item1" "item2" ... )` into a Vec<String>.
 fn parse_bash_array_string(raw_str: &str) -> Vec<String> {
-    log::debug!("Attempting to parse raw bash-array string: '{}'", raw_str);
+    log::debug!("Attempting to parse raw bash-array string: '{raw_str}'");
 
     if raw_str.starts_with('(') && raw_str.ends_with(')') {
         // Remove the outer parentheses
@@ -252,14 +251,13 @@ fn parse_bash_array_string(raw_str: &str) -> Vec<String> {
             .filter(|s| !s.is_empty())
             .collect();
 
-        log::debug!("Parsed list from bash-array string: {:?}", parsed_list);
+        log::debug!("Parsed list from bash-array string: {parsed_list:?}");
         parsed_list
     } else if !raw_str.trim().is_empty() {
         // If the string is not empty but doesn't match the expected format,
         // log a warning and return an empty list.
         log::warn!(
-            "String ('{}') is not in the expected bash-array format '( \"item1\" ... )'. Treating as empty list.",
-            raw_str
+            "String ('{raw_str}') is not in the expected bash-array format '( \"item1\" ... )'. Treating as empty list."
         );
         vec![]
     } else {