fix(admin): report global heal operations status

Author: cxymds

crates/cli/src/commands/admin/heal.rs

@@ -313,7 +313,7 @@ fn print_heal_status(status: &HealStatus, formatter: &Formatter) {
             formatter.println(&format!("  Last Update:   {}", last_update));
         }
     } else {
-        formatter.println("  No heal operation currently running.");
+        formatter.println("  No active heal operation.");
     }
 }
 
@@ -586,6 +586,15 @@ mod tests {
         assert!(output.status.is_none());
     }
 
+    #[test]
+    fn test_heal_task_request_rejects_token_without_bucket() {
+        let formatter = Formatter::default();
+
+        let result = heal_task_request(None, None, Some("root-token".to_string()), &formatter);
+
+        assert!(matches!(result, Err(ExitCode::UsageError)));
+    }
+
     #[test]
     fn test_heal_status_output_from() {
         let status = HealStatus {

crates/s3/src/admin.rs

@@ -401,22 +401,46 @@ struct BackgroundHealStatusResponse {
     heal_queue_length: u64,
     #[serde(default)]
     heal_active_tasks: u64,
+    #[serde(default)]
+    heal_operations: Option<BackgroundHealOperations>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct BackgroundHealOperations {
+    #[serde(default)]
+    queue_length: u64,
+    #[serde(default)]
+    active_tasks: u64,
 }
 
 impl From<BackgroundHealStatusResponse> for HealStatus {
     fn from(response: BackgroundHealStatusResponse) -> Self {
         let scan_mode = background_heal_scan_mode(response.current_scan_mode);
         let legacy_healing = scan_mode.is_none() && response.bitrot_start_time.is_some();
+        let queue_length = response
+            .heal_operations
+            .as_ref()
+            .map_or(response.heal_queue_length, |operations| {
+                response.heal_queue_length.max(operations.queue_length)
+            });
+        let active_tasks = response
+            .heal_operations
+            .as_ref()
+            .map_or(response.heal_active_tasks, |operations| {
+                response.heal_active_tasks.max(operations.active_tasks)
+            });
+
         Self {
             healing: matches!(scan_mode, Some(HealScanMode::Deep))
-                || response.heal_queue_length > 0
-                || response.heal_active_tasks > 0
+                || queue_length > 0
+                || active_tasks > 0
                 || legacy_healing,
             started: response.bitrot_start_time,
             scan_mode,
             scan_cycle: response.bitrot_start_cycle,
-            heal_queue_length: response.heal_queue_length,
-            heal_active_tasks: response.heal_active_tasks,
+            heal_queue_length: queue_length,
+            heal_active_tasks: active_tasks,
             ..Default::default()
         }
     }
@@ -1371,6 +1395,7 @@ mod tests {
             current_scan_mode: Some(2),
             heal_queue_length: 3,
             heal_active_tasks: 1,
+            heal_operations: None,
         });
 
         assert!(status.healing);
@@ -1386,6 +1411,7 @@ mod tests {
             current_scan_mode: Some(1),
             heal_queue_length: 0,
             heal_active_tasks: 0,
+            heal_operations: None,
         });
         assert!(!idle.healing);
         assert_eq!(idle.scan_mode, Some(HealScanMode::Normal));
@@ -1397,6 +1423,7 @@ mod tests {
             current_scan_mode: Some(1),
             heal_queue_length: 0,
             heal_active_tasks: 0,
+            heal_operations: None,
         });
         assert!(!completed.healing);
         assert_eq!(completed.scan_mode, Some(HealScanMode::Normal));
@@ -1408,6 +1435,7 @@ mod tests {
             current_scan_mode: None,
             heal_queue_length: 0,
             heal_active_tasks: 0,
+            heal_operations: None,
         });
         assert!(legacy.healing);
 
@@ -1417,10 +1445,25 @@ mod tests {
             current_scan_mode: None,
             heal_queue_length: 0,
             heal_active_tasks: 1,
+            heal_operations: None,
         });
         assert!(active.healing);
     }
 
+    #[test]
+    fn test_background_heal_status_response_maps_nested_heal_operations() {
+        let response: BackgroundHealStatusResponse = serde_json::from_str(
+            r#"{"healOperations":{"queueLength":4,"activeTasks":1,"queuedBySource":{"admin":4}}}"#,
+        )
+        .expect("background heal status response should deserialize");
+
+        let status = HealStatus::from(response);
+
+        assert!(status.healing);
+        assert_eq!(status.heal_queue_length, 4);
+        assert_eq!(status.heal_active_tasks, 1);
+    }
+
     #[test]
     fn test_bad_request_maps_to_general_admin_error() {
         let alias = Alias::new("test", "http://localhost:9000", "access", "secret");