From 14e3eb787db126facbe9c3f2010c291393384d47 Mon Sep 17 00:00:00 2001 From: cxymds Date: Sun, 23 Aug 2026 17:29:45 +0800 Subject: [PATCH] fix(heal): correct progress accounting (#6382) * fix(heal): correct progress accounting * fix(heal): atomically persist page progress * fix(heal): preserve terminal progress counters * fix(heal): make resume handoff crash safe * fix(heal): preserve resumable bucket checkpoints * fix(heal): satisfy checkpoint outcome lint * fix(heal): preserve progress status across nodes * fix(heal): stabilize progress generations * style: restore rebalance formatting * test(heal): cover cross-set baseline generation --------- Signed-off-by: houseme Co-authored-by: overtrue Co-authored-by: houseme Co-authored-by: heihutu --- .../src/cluster/rpc/peer_rest_client.rs | 4 +- crates/heal/src/heal/erasure_healer.rs | 569 ++++++++++++++++-- crates/heal/src/heal/manager.rs | 29 +- crates/heal/src/heal/progress.rs | 509 ++++++++++++++-- crates/heal/src/heal/resume.rs | 134 ++++- crates/heal/src/heal/resume/checkpoint.rs | 205 ++++++- crates/heal/src/heal/resume/tests.rs | 157 ++++- crates/heal/src/heal/storage.rs | 49 +- crates/heal/src/heal/task.rs | 10 +- crates/heal/src/heal/task/heal_bucket.rs | 55 +- crates/heal/src/heal/task/heal_erasure_set.rs | 16 +- crates/heal/src/heal/task/heal_metadata.rs | 20 +- crates/heal/src/heal/task/heal_object.rs | 16 +- crates/heal/src/heal/task/tests.rs | 96 +++ crates/heal/src/lib.rs | 2 +- .../src/generated/proto_gen/node_service.rs | 5 +- crates/protos/src/lib.rs | 19 + crates/protos/src/node.proto | 4 +- rustfs/src/admin/handlers/heal.rs | 72 ++- rustfs/src/storage/rpc/node_service.rs | 4 +- rustfs/src/storage/rpc/node_service/heal.rs | 203 ++++++- 21 files changed, 1939 insertions(+), 239 deletions(-) diff --git a/crates/ecstore/src/cluster/rpc/peer_rest_client.rs b/crates/ecstore/src/cluster/rpc/peer_rest_client.rs index edfec184f..f28a1d17e 100644 --- a/crates/ecstore/src/cluster/rpc/peer_rest_client.rs +++ b/crates/ecstore/src/cluster/rpc/peer_rest_client.rs @@ -1090,7 +1090,9 @@ impl PeerRestClient { .await? .max_decoding_message_size(BACKGROUND_HEAL_STATUS_MAX_MESSAGE_SIZE); let response = match client - .background_heal_status(Request::new(BackgroundHealStatusRequest::default())) + .background_heal_status(Request::new(BackgroundHealStatusRequest { + protocol_version: rustfs_protos::BACKGROUND_HEAL_STATUS_PROTOCOL_VERSION, + })) .await { Ok(response) => response.into_inner(), diff --git a/crates/heal/src/heal/erasure_healer.rs b/crates/heal/src/heal/erasure_healer.rs index a0ace01b4..92a245c92 100644 --- a/crates/heal/src/heal/erasure_healer.rs +++ b/crates/heal/src/heal/erasure_healer.rs @@ -13,10 +13,10 @@ // limitations under the License. use crate::heal::{ - progress::HealProgress, + progress::{HealProgress, add_bytes, increment_counter}, resume::{ - CheckpointManager, ReplacementTargetIdentity, ResumeManager, ResumeUtils, compose_key, - replacement_target_identities_match, + CheckpointManager, CheckpointObjectOutcome, CheckpointObjectOutcomeRecord, ReplacementTargetIdentity, ResumeManager, + ResumeUtils, compose_key, replacement_target_identities_match, }, storage::{HealStorageAPI, next_heal_listing_token}, task::{demote_to_debug_when, is_missing_object_dir_heal_result, take_failure_log_sample}, @@ -415,6 +415,9 @@ impl ErasureSetHealer { && state.successful_objects == 0 && state.failed_objects == 0 && state.skipped_objects == 0 + && state.skipped_new_versions == 0 + && state.skipped_ilm_expired == 0 + && state.processed_bytes == 0 { // schedule_retry persists the authoritative resume reset before // resetting the checkpoint. Reapply the checkpoint reset after @@ -479,6 +482,23 @@ impl ErasureSetHealer { // 2. initialize progress self.initialize_progress(buckets, &state).await; + let (baseline_known, baseline_count, baseline_size, baseline_generation) = { + let baseline = self.progress.read().await; + ( + baseline.baseline_known, + baseline.objects_total_count, + baseline.objects_total_size, + baseline.baseline_generation, + ) + }; + if baseline_known { + resume_manager + .set_progress_baseline(baseline_count, baseline_size, baseline_generation) + .await?; + checkpoint_manager + .set_progress_baseline(baseline_count, baseline_size, baseline_generation) + .await?; + } // 3. continue from checkpoint let current_bucket_index = checkpoint.current_bucket_index; @@ -488,12 +508,66 @@ impl ErasureSetHealer { let mut successful_objects = state.successful_objects; let mut failed_objects = state.failed_objects; let mut skipped_objects = state.skipped_objects; + let checkpoint_has_progress = checkpoint.baseline_known + || checkpoint.successful_objects > 0 + || checkpoint.failed_object_count > 0 + || checkpoint.skipped_object_count > 0 + || checkpoint.skipped_new_versions > 0 + || checkpoint.skipped_ilm_expired > 0 + || checkpoint.processed_bytes > 0 + || checkpoint.total_objects > 0 + || checkpoint.total_bytes > 0 + || checkpoint.baseline_generation.is_some() + || checkpoint.counter_unknown; + let checkpoint_generation_mismatch = checkpoint.baseline_known && checkpoint.baseline_generation != baseline_generation; + let mut restored_counter_unknown = state.counter_unknown || checkpoint.counter_unknown; + if checkpoint_has_progress { + successful_objects = checkpoint.successful_objects; + failed_objects = checkpoint.failed_object_count; + skipped_objects = checkpoint.skipped_object_count; + let restored_processed_objects = successful_objects + .checked_add(failed_objects) + .and_then(|value| value.checked_add(skipped_objects)) + .and_then(|value| value.checked_add(checkpoint.skipped_new_versions)) + .and_then(|value| value.checked_add(checkpoint.skipped_ilm_expired)); + let checkpoint_counter_overflow = restored_processed_objects.is_none(); + restored_counter_unknown |= checkpoint_counter_overflow; + processed_objects = restored_processed_objects.unwrap_or(u64::MAX); + let mut progress = self.progress.write().await; + progress.objects_scanned = processed_objects; + progress.objects_healed = successful_objects; + progress.objects_failed = failed_objects; + progress.skipped_objects = skipped_objects; + progress.skipped_new_versions = checkpoint.skipped_new_versions; + progress.skipped_ilm_expired = checkpoint.skipped_ilm_expired; + if checkpoint.baseline_known && !checkpoint_generation_mismatch { + progress.objects_total_count = checkpoint.total_objects; + progress.objects_total_size = checkpoint.total_bytes; + progress.baseline_generation = checkpoint.baseline_generation; + progress.baseline_known = true; + } + progress.bytes_processed = checkpoint.processed_bytes; + progress.counter_unknown = state.counter_unknown || checkpoint.counter_unknown; + progress.refresh_progress_percentage(); + if checkpoint_generation_mismatch || checkpoint_counter_overflow || progress.counter_unknown { + progress.mark_unknown(); + } + } + if checkpoint_generation_mismatch { + restored_counter_unknown = true; + } + if restored_counter_unknown { + checkpoint_manager.mark_counter_unknown().await?; + resume_manager.mark_counter_unknown().await?; + } let mut failed_buckets = 0u64; // 4. process remaining buckets for (bucket_idx, bucket) in buckets.iter().enumerate().skip(current_bucket_index) { // check if completed if state.completed_buckets.contains(bucket) { + checkpoint_manager.complete_bucket(bucket_idx.saturating_add(1)).await?; + current_object_index = 0; continue; } @@ -521,13 +595,42 @@ impl ErasureSetHealer { return bucket_result; } - // update checkpoint position - checkpoint_manager.update_position(bucket_idx, current_object_index).await?; - // update progress - resume_manager - .update_progress(processed_objects, successful_objects, failed_objects, skipped_objects) + let progress_snapshot = self.progress.read().await; + let bytes_processed = progress_snapshot.bytes_processed; + let skipped_new_versions = progress_snapshot.skipped_new_versions; + let skipped_ilm_expired = progress_snapshot.skipped_ilm_expired; + let counter_unknown = progress_snapshot.counter_unknown; + drop(progress_snapshot); + // The checkpoint is the recovery authority for object progress. + // Publish its counters and fence before the resume summary so a + // crash between the two stores cannot make recovery select newer + // summary bytes with an older checkpoint ledger. + if counter_unknown { + checkpoint_manager.mark_counter_unknown().await?; + } + checkpoint_manager + .update_progress(successful_objects, failed_objects, skipped_objects, bytes_processed) .await?; + checkpoint_manager + .set_skipped_version_counts(skipped_new_versions, skipped_ilm_expired) + .await?; + checkpoint_manager.update_position(bucket_idx, current_object_index).await?; + resume_manager + .update_progress_with_bytes( + processed_objects, + successful_objects, + failed_objects, + skipped_objects, + bytes_processed, + ) + .await?; + resume_manager + .set_skipped_version_counts(skipped_new_versions, skipped_ilm_expired) + .await?; + if counter_unknown { + resume_manager.mark_counter_unknown().await?; + } // check cancel status if self.cancel_token.is_cancelled() { @@ -547,6 +650,7 @@ impl ErasureSetHealer { match bucket_result { Ok(_) => { resume_manager.complete_bucket(bucket).await?; + checkpoint_manager.complete_bucket(bucket_idx.saturating_add(1)).await?; debug!( target: "rustfs::heal::erasure_healer", event = EVENT_HEAL_ERASURE_BUCKET_STATE, @@ -572,7 +676,9 @@ impl ErasureSetHealer { error = %e, "Erasure set bucket heal failed" ); - // continue to next bucket, do not interrupt the whole process + // A single durable cursor and ledger cannot safely preserve + // this bucket while processing a later one. + break; } } @@ -780,20 +886,49 @@ impl ErasureSetHealer { // Per-version dedup identity — the single canonical key. let key = compose_key(&item.name, item.version_id.as_deref()); - if checkpoint.processed_objects.contains(&key) || checkpoint.skipped_objects.contains(&key) { + if checkpoint.processed_objects.contains(&key) + || checkpoint.failed_objects.contains(&key) + || checkpoint.skipped_objects.contains(&key) + { continue; } if should_skip_new_version(item.mod_time_unix_nanos, started_at_secs) { - checkpoint_manager.add_processed_object(key).await?; - *processed_objects = processed_objects.saturating_add(1); + let counter_ok = increment_counter(processed_objects); completed_in_page = completed_in_page.saturating_add(1); counter!("rustfs_heal_skipped_new_versions_total").increment(1); - { + let (outcome_record, counter_unknown) = { let mut progress = self.progress.write().await; progress.record_skipped_new_version(); progress.set_current_object(Some(format!("skipped_new: {bucket}/{}", item.name))); - progress.update_progress(*processed_objects, *successful_objects, *failed_objects, bytes_processed); + progress.update_object_progress( + *processed_objects, + *successful_objects, + *failed_objects, + *skipped_objects, + bytes_processed, + ); + if !counter_ok { + progress.mark_unknown(); + } + ( + CheckpointObjectOutcomeRecord { + object: key, + outcome: CheckpointObjectOutcome::Processed, + successful: progress.objects_healed, + failed: progress.objects_failed, + skipped: progress.skipped_objects, + bytes: progress.bytes_processed, + skipped_new_versions: progress.skipped_new_versions, + skipped_ilm_expired: progress.skipped_ilm_expired, + counter_unknown: progress.counter_unknown, + }, + progress.counter_unknown, + ) + }; + checkpoint_manager.record_object_outcome(outcome_record).await?; + if counter_unknown { + resume_manager.mark_counter_unknown().await?; } debug!( target: "rustfs::heal::erasure_healer", @@ -825,15 +960,41 @@ impl ErasureSetHealer { ) .await? { - checkpoint_manager.add_processed_object(key).await?; - *processed_objects = processed_objects.saturating_add(1); + let counter_ok = increment_counter(processed_objects); completed_in_page = completed_in_page.saturating_add(1); counter!("rustfs_heal_skipped_ilm_expired_total").increment(1); - { + let (outcome_record, counter_unknown) = { let mut progress = self.progress.write().await; progress.record_skipped_ilm_expired(); progress.set_current_object(Some(format!("skipped_ilm: {bucket}/{}", item.name))); - progress.update_progress(*processed_objects, *successful_objects, *failed_objects, bytes_processed); + progress.update_object_progress( + *processed_objects, + *successful_objects, + *failed_objects, + *skipped_objects, + bytes_processed, + ); + if !counter_ok { + progress.mark_unknown(); + } + ( + CheckpointObjectOutcomeRecord { + object: key, + outcome: CheckpointObjectOutcome::Processed, + successful: progress.objects_healed, + failed: progress.objects_failed, + skipped: progress.skipped_objects, + bytes: progress.bytes_processed, + skipped_new_versions: progress.skipped_new_versions, + skipped_ilm_expired: progress.skipped_ilm_expired, + counter_unknown: progress.counter_unknown, + }, + progress.counter_unknown, + ) + }; + checkpoint_manager.record_object_outcome(outcome_record).await?; + if counter_unknown { + resume_manager.mark_counter_unknown().await?; } debug!( target: "rustfs::heal::erasure_healer", @@ -959,11 +1120,11 @@ impl ErasureSetHealer { while let Some((key, object, version_id, result)) = page_tasks.next().await { let (object_size, result) = result; - match result { + let mut telemetry_unknown = false; + let checkpoint_outcome = match result { Ok(true) => { - *successful_objects += 1; - bytes_processed = bytes_processed.saturating_add(object_size); - checkpoint_manager.add_processed_object(key).await?; + telemetry_unknown |= !increment_counter(successful_objects); + telemetry_unknown |= !add_bytes(&mut bytes_processed, object_size); debug!( target: "rustfs::heal::erasure_healer", event = EVENT_HEAL_ERASURE_OBJECT_STATE, @@ -976,11 +1137,11 @@ impl ErasureSetHealer { state = "healed", "Erasure set object healed" ); + CheckpointObjectOutcome::Processed } Ok(false) => { - checkpoint_manager.add_processed_object(key).await?; - *successful_objects += 1; - bytes_processed = bytes_processed.saturating_add(object_size); + telemetry_unknown |= !increment_counter(successful_objects); + telemetry_unknown |= !add_bytes(&mut bytes_processed, object_size); debug!( target: "rustfs::heal::erasure_healer", event = EVENT_HEAL_ERASURE_OBJECT_STATE, @@ -993,12 +1154,12 @@ impl ErasureSetHealer { state = "missing_treated_as_ok", "Erasure set missing object treated as ok" ); + CheckpointObjectOutcome::Processed } Err(err @ Error::TaskCancelled) | Err(err @ Error::TaskTimeout) => return Err(err), Err(Error::TransientSkip { message }) => { - *skipped_objects += 1; - bytes_processed = bytes_processed.saturating_add(object_size); - checkpoint_manager.add_skipped_object(key).await?; + telemetry_unknown |= !increment_counter(skipped_objects); + telemetry_unknown |= !add_bytes(&mut bytes_processed, object_size); demote_to_debug_when!(!take_failure_log_sample(&mut transient_skip_samples_logged), warn, target: "rustfs::heal::erasure_healer", { event = EVENT_HEAL_ERASURE_OBJECT_STATE, component = LOG_COMPONENT_HEAL, @@ -1011,11 +1172,11 @@ impl ErasureSetHealer { error = %message, "Erasure set object heal skipped due to transient error" }); + CheckpointObjectOutcome::Skipped } Err(err) => { - *failed_objects += 1; - bytes_processed = bytes_processed.saturating_add(object_size); - checkpoint_manager.add_failed_object(key).await?; + telemetry_unknown |= !increment_counter(failed_objects); + telemetry_unknown |= !add_bytes(&mut bytes_processed, object_size); demote_to_debug_when!(!take_failure_log_sample(&mut failure_samples_logged), warn, target: "rustfs::heal::erasure_healer", { event = EVENT_HEAL_ERASURE_OBJECT_STATE, component = LOG_COMPONENT_HEAL, @@ -1028,15 +1189,43 @@ impl ErasureSetHealer { error = %err, "Erasure set object heal failed" }); + CheckpointObjectOutcome::Failed } - } + }; - *processed_objects += 1; + telemetry_unknown |= !increment_counter(processed_objects); completed_in_page += 1; - { + let (outcome_record, counter_unknown) = { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("{bucket}/{object}"))); - progress.update_progress(*processed_objects, *successful_objects, *failed_objects, bytes_processed); + progress.update_object_progress( + *processed_objects, + *successful_objects, + *failed_objects, + *skipped_objects, + bytes_processed, + ); + if telemetry_unknown { + progress.mark_unknown(); + } + ( + CheckpointObjectOutcomeRecord { + object: key, + outcome: checkpoint_outcome, + successful: progress.objects_healed, + failed: progress.objects_failed, + skipped: progress.skipped_objects, + bytes: progress.bytes_processed, + skipped_new_versions: progress.skipped_new_versions, + skipped_ilm_expired: progress.skipped_ilm_expired, + counter_unknown: progress.counter_unknown, + }, + progress.counter_unknown, + ) + }; + checkpoint_manager.record_object_outcome(outcome_record).await?; + if counter_unknown { + resume_manager.mark_counter_unknown().await?; } if completed_in_page.is_multiple_of(100) { @@ -1046,16 +1235,22 @@ impl ErasureSetHealer { *current_object_index = global_obj_idx; - // Persist the authoritative cursor FIRST (points at the next page - // boundary), then prune the per-version dedup sets. Both are - // idempotent under crash: heal_object re-heals safely. - let next_cursor = if is_truncated { next_token.clone() } else { None }; - resume_manager.set_resume_cursor(next_cursor.clone()).await?; - checkpoint_manager.complete_page(bucket_index, *current_object_index).await?; + // Persist the checkpoint ledger and page position before exposing + // the next resume cursor. A crash before cursor publication keeps + // the page identities available for exact-once replay. + checkpoint_manager.advance_page(bucket_index, *current_object_index).await?; // Check if there are more pages if !is_truncated { break; } + continuation_token = next_heal_listing_token(bucket, "", next_token, is_truncated)?; + if continuation_token.is_none() { + // A truncated page without a continuation token is terminal. + // Retain its ledger until bucket completion is durable. + break; + } + resume_manager.set_resume_cursor(continuation_token.clone()).await?; + checkpoint_manager.prune_completed_page().await?; // Anti-loop guard: an empty page reported as truncated cannot advance // the cursor (there is no last identity to move past), so treat it as a @@ -1074,12 +1269,6 @@ impl ErasureSetHealer { ))); } previous_page_last = page_last; - - continuation_token = next_heal_listing_token(bucket, "", next_token, is_truncated)?; - if continuation_token.is_none() { - // Truncated but no continuation token: treat as end of listing. - break; - } } Ok(()) @@ -1088,10 +1277,66 @@ impl ErasureSetHealer { /// initialize progress tracking async fn initialize_progress(&self, _buckets: &[String], state: &crate::heal::resume::ResumeState) { let mut progress = self.progress.write().await; - progress.objects_scanned = state.total_objects; + let existing_baseline = ( + progress.objects_total_count, + progress.objects_total_size, + progress.baseline_generation, + progress.progress_state, + progress.baseline_known, + ); + let baseline_generation_mismatch = + state.baseline_known && existing_baseline.4 && state.baseline_generation != existing_baseline.2; + let use_persisted_baseline = state.baseline_known && !baseline_generation_mismatch; + progress.objects_scanned = state.processed_objects; progress.objects_healed = state.successful_objects; progress.objects_failed = state.failed_objects; - progress.bytes_processed = 0; // Resume state tracks object counts, not byte counters. + progress.skipped_objects = state.skipped_objects; + progress.skipped_new_versions = state.skipped_new_versions; + progress.skipped_ilm_expired = state.skipped_ilm_expired; + progress.bytes_processed = state.processed_bytes; + progress.counter_unknown = state.counter_unknown; + if use_persisted_baseline + || existing_baseline.0 > 0 + || existing_baseline.1 > 0 + || existing_baseline.2.is_some() + || existing_baseline.4 + { + progress.objects_total_count = if use_persisted_baseline { + state.total_objects + } else { + existing_baseline.0 + }; + progress.objects_total_size = if use_persisted_baseline { + state.total_bytes + } else { + existing_baseline.1 + }; + progress.baseline_generation = if use_persisted_baseline { + state.baseline_generation + } else { + existing_baseline.2 + }; + progress.baseline_known = use_persisted_baseline + || existing_baseline.0 > 0 + || existing_baseline.1 > 0 + || existing_baseline.2.is_some() + || existing_baseline.4; + } + progress.progress_state = if use_persisted_baseline + || existing_baseline.0 > 0 + || existing_baseline.1 > 0 + || existing_baseline.2.is_some() + || existing_baseline.4 + { + crate::heal::progress::HealProgressState::Running + } else { + crate::heal::progress::HealProgressState::Indeterminate + }; + if baseline_generation_mismatch || state.counter_unknown { + progress.mark_unknown(); + } + progress.ledger_complete = false; + progress.refresh_progress_percentage(); progress.start_time = UNIX_EPOCH.checked_add(Duration::from_secs(state.start_time)); progress.last_update_time = UNIX_EPOCH.checked_add(Duration::from_secs(state.last_update)); progress.set_current_object(state.current_object.clone()); @@ -1269,8 +1514,8 @@ mod resume_loop_tests { }; use crate::heal::progress::HealProgress; use crate::heal::resume::{ - CheckpointManager, RESUME_CHECKPOINT_FILE, ReplacementTargetIdentity, ResumeDeleteFailure, ResumeManager, ResumeUtils, - compose_key, + CheckpointManager, CheckpointObjectOutcome, CheckpointObjectOutcomeRecord, RESUME_CHECKPOINT_FILE, + ReplacementTargetIdentity, ResumeDeleteFailure, ResumeManager, ResumeUtils, compose_key, }; use crate::heal::storage::{HealLifecycleExpiryContext, HealListItem, HealObjectInfo, HealStorageAPI}; use crate::heal::storage_api::status::BucketInfo; @@ -1410,6 +1655,7 @@ mod resume_loop_tests { list_include_lifecycle_object_info: Mutex>, replacement_target_identity_sequences: Mutex>>, fail_listing: AtomicBool, + fail_listing_buckets: Mutex>, } impl FakeStorage { @@ -1446,6 +1692,9 @@ mod resume_loop_tests { fn fail_listing(&self) { self.fail_listing.store(true, Ordering::SeqCst); } + fn fail_bucket_listing(&self, bucket: &str) { + self.fail_listing_buckets.lock().unwrap().insert(bucket.to_string()); + } } #[async_trait::async_trait] @@ -1536,7 +1785,7 @@ mod resume_loop_tests { } async fn list_objects_for_heal_page( &self, - _bucket: &str, + bucket: &str, _prefix: &str, continuation_token: Option<&str>, include_lifecycle_object_info: bool, @@ -1545,7 +1794,7 @@ mod resume_loop_tests { .lock() .unwrap() .push(include_lifecycle_object_info); - if self.fail_listing.load(Ordering::SeqCst) { + if self.fail_listing.load(Ordering::SeqCst) || self.fail_listing_buckets.lock().unwrap().contains(bucket) { return Err(Error::other("injected listing failure")); } let key = continuation_token.map(str::to_string); @@ -1923,6 +2172,49 @@ mod resume_loop_tests { assert!(state.completed_buckets.is_empty(), "the failed bucket must remain resumable"); } + #[tokio::test] + async fn bucket_failure_stops_before_a_later_bucket_checkpoint() { + let env = make_env().await; + let task_id = ResumeUtils::generate_task_id(); + let buckets = vec!["a".to_string(), "b".to_string()]; + let resume = ResumeManager::new( + env.healer.disk.clone(), + task_id.clone(), + "erasure_set".to_string(), + "pool_0_set_0".to_string(), + buckets.clone(), + ) + .await + .unwrap(); + let checkpoint = CheckpointManager::new(env.healer.disk.clone(), task_id.clone()) + .await + .unwrap(); + env.storage.fail_bucket_listing("a"); + for _ in 0..3 { + assert!(resume.schedule_retry().await.unwrap()); + } + + env.healer + .execute_heal_with_resume(&buckets, "pool_0_set_0", &resume, &checkpoint) + .await + .expect_err("the first bucket failure must keep the pass incomplete"); + let persisted = checkpoint.get_checkpoint().await; + assert_eq!(persisted.current_bucket_index, 0); + assert!(resume.get_state().await.completed_buckets.is_empty()); + + let resumed = ResumeManager::load_from_disk(env.healer.disk.clone(), &task_id) + .await + .unwrap(); + let checkpoint = CheckpointManager::load_from_disk(env.healer.disk.clone(), &task_id) + .await + .unwrap(); + env.healer + .execute_heal_with_resume(&buckets, "pool_0_set_0", &resumed, &checkpoint) + .await + .expect_err("recovery must retry the earlier failed bucket"); + assert!(!resumed.get_state().await.completed); + } + #[tokio::test] async fn completed_resume_state_is_not_selected_for_a_new_heal() { let env = make_env().await; @@ -2112,8 +2404,175 @@ mod resume_loop_tests { let mut names: Vec = env.storage.calls().into_iter().map(|(n, _)| n).collect(); names.sort(); assert_eq!(names, vec!["a", "b", "c", "d"], "every object exactly once, none dropped/doubled"); - // Final page not truncated => cursor cleared. - assert_eq!(env.resume.resume_cursor().await, None); + // Keep the final page cursor until the outer loop durably completes the + // bucket, so a crash can replay only this page against its identities. + assert_eq!(env.resume.resume_cursor().await, Some("t1".to_string())); + } + + #[tokio::test] + async fn persisted_failure_waits_for_the_bounded_retry_after_page_replay() { + let env = make_env().await; + env.storage.set_page( + None, + Page { + items: vec![item("object", Some("v1"), false)], + next: None, + truncated: false, + }, + ); + env.checkpoint + .record_object_outcome(CheckpointObjectOutcomeRecord { + object: compose_key("object", Some("v1")), + outcome: CheckpointObjectOutcome::Failed, + successful: 0, + failed: 1, + skipped: 0, + bytes: 0, + skipped_new_versions: 0, + skipped_ilm_expired: 0, + counter_unknown: false, + }) + .await + .unwrap(); + env.checkpoint.advance_page(0, 1).await.unwrap(); + + let resumed = ResumeManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + let checkpoint = CheckpointManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + + env.healer + .execute_heal_with_resume(&["b".to_string()], "pool_0_set_0", &resumed, &checkpoint) + .await + .expect_err("the persisted failure must schedule a bounded retry"); + assert!( + env.storage.calls().is_empty(), + "the failed identity must not be repeated in the same pass" + ); + + env.healer + .execute_heal_with_resume(&["b".to_string()], "pool_0_set_0", &resumed, &checkpoint) + .await + .expect("the bounded retry must heal the object"); + assert_eq!(env.storage.calls(), vec![("object".to_string(), Some("v1".to_string()))]); + let state = resumed.get_state().await; + assert_eq!(state.successful_objects, 1); + assert_eq!(state.failed_objects, 0); + } + + #[tokio::test] + async fn final_page_crash_replays_only_the_retained_page_identities() { + let env = make_env().await; + env.storage.set_page( + None, + Page { + items: vec![item("first", Some("v1"), false)], + next: Some("final-page".to_string()), + truncated: true, + }, + ); + env.storage.set_page( + Some("final-page"), + Page { + items: vec![item("last", Some("v1"), false)], + next: None, + truncated: false, + }, + ); + + let (processed, successful, failed, skipped, result) = run(&env).await; + result.expect("the bucket pass must finish before the simulated crash"); + assert_eq!((processed, successful, failed, skipped), (2, 2, 0, 0)); + + let resumed = ResumeManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + let checkpoint = CheckpointManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + env.healer + .execute_heal_with_resume(&["b".to_string()], "pool_0_set_0", &resumed, &checkpoint) + .await + .expect("the retained final-page ledger must make recovery exact"); + + assert_eq!( + env.storage.calls(), + vec![ + ("first".to_string(), Some("v1".to_string())), + ("last".to_string(), Some("v1".to_string())) + ] + ); + let state = resumed.get_state().await; + assert_eq!(state.successful_objects, 2); + assert_eq!(state.processed_objects, 2); + } + + #[tokio::test] + async fn truncated_page_without_token_retains_its_replay_ledger() { + let env = make_env().await; + env.storage.set_page( + None, + Page { + items: vec![item("object", Some("v1"), false)], + next: None, + truncated: true, + }, + ); + + let (processed, successful, failed, skipped, result) = run(&env).await; + result.expect("the tokenless truncated page is a terminal page"); + assert_eq!((processed, successful, failed, skipped), (1, 1, 0, 0)); + + let resumed = ResumeManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + let checkpoint = CheckpointManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + env.healer + .execute_heal_with_resume(&["b".to_string()], "pool_0_set_0", &resumed, &checkpoint) + .await + .expect("terminal-page recovery must not replay a durable identity"); + + assert_eq!(env.storage.calls(), vec![("object".to_string(), Some("v1".to_string()))]); + let state = resumed.get_state().await; + assert_eq!(state.successful_objects, 1); + assert_eq!(state.processed_objects, 1); + } + + #[tokio::test] + async fn completed_bucket_reconciles_its_final_page_checkpoint_after_crash() { + let env = make_env().await; + env.storage.set_page( + None, + Page { + items: vec![item("object", Some("v1"), false)], + next: None, + truncated: false, + }, + ); + + let (_, _, _, _, result) = run(&env).await; + result.expect("the bucket pass must finish before the simulated crash"); + env.resume.complete_bucket("b").await.unwrap(); + + let resumed = ResumeManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + let checkpoint = CheckpointManager::load_from_disk(env.healer.disk.clone(), &env.task_id) + .await + .unwrap(); + env.healer + .execute_heal_with_resume(&["b".to_string()], "pool_0_set_0", &resumed, &checkpoint) + .await + .expect("recovery must finish the checkpoint transition without replaying the bucket"); + + assert_eq!(env.storage.calls(), vec![("object".to_string(), Some("v1".to_string()))]); + let checkpoint = checkpoint.get_checkpoint().await; + assert_eq!(checkpoint.current_bucket_index, 1); + assert!(checkpoint.processed_objects.is_empty()); } #[tokio::test] diff --git a/crates/heal/src/heal/manager.rs b/crates/heal/src/heal/manager.rs index 7c98b91f5..e092520f9 100644 --- a/crates/heal/src/heal/manager.rs +++ b/crates/heal/src/heal/manager.rs @@ -2110,34 +2110,11 @@ impl HealManager { return None; } - let mut snapshot = HealProgress::default(); + let mut progresses = Vec::with_capacity(active_tasks.len()); for task in active_tasks { - let progress = task.get_progress().await; - snapshot.objects_scanned = snapshot.objects_scanned.saturating_add(progress.objects_scanned); - snapshot.objects_healed = snapshot.objects_healed.saturating_add(progress.objects_healed); - snapshot.objects_failed = snapshot.objects_failed.saturating_add(progress.objects_failed); - snapshot.skipped_new_versions = snapshot.skipped_new_versions.saturating_add(progress.skipped_new_versions); - snapshot.skipped_ilm_expired = snapshot.skipped_ilm_expired.saturating_add(progress.skipped_ilm_expired); - snapshot.objects_total_count = snapshot.objects_total_count.saturating_add(progress.objects_total_count); - snapshot.objects_total_size = snapshot.objects_total_size.saturating_add(progress.objects_total_size); - snapshot.bytes_processed = snapshot.bytes_processed.saturating_add(progress.bytes_processed); - snapshot.start_time = match (snapshot.start_time, progress.start_time) { - (Some(current), Some(next)) => Some(current.min(next)), - (None, next) => next, - (current, None) => current, - }; - snapshot.last_update_time = match (snapshot.last_update_time, progress.last_update_time) { - (Some(current), Some(next)) => Some(current.max(next)), - (None, next) => next, - (current, None) => current, - }; - if progress.current_object.is_some() { - snapshot.current_object = progress.current_object; - } + progresses.push(task.get_progress().await); } - snapshot.refresh_progress_percentage(); - snapshot.refresh_estimated_completion_time(); - Some(snapshot) + crate::heal::progress::aggregate_heal_progress(progresses) } } diff --git a/crates/heal/src/heal/progress.rs b/crates/heal/src/heal/progress.rs index d30b82ad6..7f4ba3b26 100644 --- a/crates/heal/src/heal/progress.rs +++ b/crates/heal/src/heal/progress.rs @@ -15,15 +15,91 @@ use serde::{Deserialize, Serialize}; use std::time::{Duration, SystemTime}; -#[derive(Debug, Default, Clone, Serialize, Deserialize)] +pub(crate) fn stable_generation(parts: &[&[u8]]) -> u64 { + let mut hash = 0xcbf29ce484222325u64; + for part in parts { + for byte in (part.len() as u64).to_be_bytes().into_iter().chain(part.iter().copied()) { + hash ^= u64::from(byte); + hash = hash.wrapping_mul(0x100000001b3); + } + } + hash +} + +#[cfg(test)] +mod stable_generation_tests { + use super::stable_generation; + + #[test] + fn stable_generation_has_a_fixed_vector() { + assert_eq!(stable_generation(&[b"rustfs", b"heal", b"42"]), 11_007_672_338_488_385_056); + } +} + +pub(crate) fn increment_counter(counter: &mut u64) -> bool { + match counter.checked_add(1) { + Some(next) => { + *counter = next; + true + } + None => { + *counter = u64::MAX; + false + } + } +} + +pub(crate) fn add_bytes(total: &mut u64, amount: u64) -> bool { + match total.checked_add(amount) { + Some(next) => { + *total = next; + true + } + None => { + *total = u64::MAX; + false + } + } +} + +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] +pub enum HealProgressKind { + #[default] + Unknown, + Stage, + ObjectSweep, +} + +/// Whether the object ledger can produce a meaningful percentage. +/// +/// A zero-valued baseline is not a completed scan: it means that no complete +/// usage snapshot was available. Keep this state explicit so callers do not +/// mistake the legacy `0.0` wire value for a measured zero-percent result. +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub enum HealProgressState { + #[default] + Unknown, + Indeterminate, + Running, + Completed, +} + +#[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)] +#[serde(default, rename_all = "camelCase")] pub struct HealProgress { + #[serde(default)] + pub kind: HealProgressKind, /// Objects scanned pub objects_scanned: u64, /// Objects healed pub objects_healed: u64, /// Objects failed pub objects_failed: u64, + /// Versions deferred for a later retry pass. + #[serde(default)] + pub skipped_objects: u64, /// Versions skipped because they were written after this heal started pub skipped_new_versions: u64, /// Versions skipped because lifecycle already selected them for expiry @@ -44,11 +120,38 @@ pub struct HealProgress { pub last_update_time: Option, /// Estimated completion time pub estimated_completion_time: Option, + /// Current stage number. Stage updates are intentionally independent from + /// the object ledger below. + #[serde(default)] + pub stage_current: u64, + /// Number of stages in the current task. + #[serde(default)] + pub stage_total: u64, + /// Explicitly distinguishes a missing usage baseline from measured 0%. + #[serde(default)] + pub progress_state: HealProgressState, + /// True only after the task's durable completion ledger was committed. + #[serde(default)] + pub ledger_complete: bool, + /// Generation of the usage snapshot used for the baseline, if available. + #[serde(default)] + pub baseline_generation: Option, + /// Whether the baseline was explicitly observed. This is separate from + /// the counters so a known empty scope (0 objects, 0 bytes) is not + /// confused with a legacy snapshot that omitted the baseline fields. + #[serde(default)] + pub baseline_known: bool, + /// Internal telemetry fence set when an aggregate counter overflows or + /// becomes inconsistent. It prevents a later refresh from fabricating a + /// percentage from the poisoned values. + #[serde(default)] + pub counter_unknown: bool, } impl HealProgress { pub fn new() -> Self { Self { + kind: HealProgressKind::Unknown, start_time: Some(SystemTime::now()), last_update_time: Some(SystemTime::now()), ..Default::default() @@ -56,12 +159,87 @@ impl HealProgress { } pub fn update_progress(&mut self, scanned: u64, healed: u64, failed: u64, bytes: u64) { + self.update_object_sweep_progress(scanned, healed, failed, bytes); + } + + pub fn update_object_sweep_progress(&mut self, scanned: u64, healed: u64, failed: u64, bytes: u64) { + self.kind = HealProgressKind::ObjectSweep; self.objects_scanned = scanned; self.objects_healed = healed; self.objects_failed = failed; self.bytes_processed = bytes; self.last_update_time = Some(SystemTime::now()); + let explicit_skipped = match self.skipped_new_versions.checked_add(self.skipped_ilm_expired) { + Some(value) => value, + None => { + self.mark_unknown(); + 0 + } + }; + let skipped = healed + .checked_add(failed) + .and_then(|value| value.checked_add(explicit_skipped)) + .and_then(|value| scanned.checked_sub(value)) + .unwrap_or(0); + self.update_object_progress(scanned, healed, failed, skipped, bytes); + } + + /// Update task stage progress without modifying object counters. + pub fn update_stage(&mut self, current: u64, total: u64) { + let object_sweep_active = matches!(self.kind, HealProgressKind::ObjectSweep); + if !object_sweep_active { + self.kind = HealProgressKind::Stage; + } + self.ledger_complete = false; + self.stage_current = current.min(total); + self.stage_total = total; + if object_sweep_active { + self.last_update_time = Some(SystemTime::now()); + self.refresh_progress_percentage(); + return; + } + self.progress_state = if total == 0 { + HealProgressState::Indeterminate + } else { + HealProgressState::Running + }; + self.progress_percentage = if total == 0 { + 0.0 + } else { + (current as f64 / total as f64 * 100.0).min(100.0) + }; + self.last_update_time = Some(SystemTime::now()); + } + + /// Update the disjoint object ledger. `scanned` is the number of terminal + /// object outcomes and must equal healed + failed + deferred skipped plus + /// the two terminal skip classes. Overflow is a corrupt/unknown counter + /// state, not a reason to abort a completed heal. + pub fn update_object_progress(&mut self, scanned: u64, healed: u64, failed: u64, skipped: u64, bytes: u64) { + self.kind = HealProgressKind::ObjectSweep; + // `skipped` is the transient/deferred class. The two explicit skip + // counters are terminal classifications too, so include them in the + // same ledger without making callers maintain a second aggregate. + let outcomes = healed + .checked_add(failed) + .and_then(|value| value.checked_add(skipped)) + .and_then(|value| value.checked_add(self.skipped_new_versions)) + .and_then(|value| value.checked_add(self.skipped_ilm_expired)); + self.objects_scanned = scanned; + self.objects_healed = healed; + self.objects_failed = failed; + self.skipped_objects = skipped; + self.bytes_processed = bytes; + self.last_update_time = Some(SystemTime::now()); + self.ledger_complete = false; + if outcomes != Some(scanned) { + // Telemetry corruption must not abort a heal. Preserve the + // counters for diagnostics, but do not derive a percentage from a + // double-counted or overflowing ledger. + self.mark_unknown(); + return; + } self.refresh_progress_percentage(); self.refresh_estimated_completion_time(); } @@ -69,50 +247,88 @@ impl HealProgress { pub fn set_total_baseline(&mut self, objects_total_count: u64, objects_total_size: u64) { self.objects_total_count = objects_total_count; self.objects_total_size = objects_total_size; + self.baseline_known = true; self.last_update_time = Some(SystemTime::now()); self.refresh_progress_percentage(); self.refresh_estimated_completion_time(); } + pub fn set_total_baseline_with_generation(&mut self, objects_total_count: u64, objects_total_size: u64, generation: u64) { + self.baseline_generation = Some(generation); + self.set_total_baseline(objects_total_count, objects_total_size); + } + pub fn record_skipped_new_version(&mut self) { - self.skipped_new_versions = self.skipped_new_versions.saturating_add(1); + let Some(next) = self.skipped_new_versions.checked_add(1) else { + self.mark_unknown(); + return; + }; + self.skipped_new_versions = next; self.last_update_time = Some(SystemTime::now()); self.refresh_progress_percentage(); self.refresh_estimated_completion_time(); } pub fn record_skipped_ilm_expired(&mut self) { - self.skipped_ilm_expired = self.skipped_ilm_expired.saturating_add(1); + let Some(next) = self.skipped_ilm_expired.checked_add(1) else { + self.mark_unknown(); + return; + }; + self.skipped_ilm_expired = next; self.last_update_time = Some(SystemTime::now()); self.refresh_progress_percentage(); self.refresh_estimated_completion_time(); } - fn completed_for_baseline(&self) -> u64 { + fn completed_for_baseline(&self) -> Option { self.objects_healed - .saturating_add(self.objects_failed) - .saturating_add(self.skipped_new_versions) - .saturating_add(self.skipped_ilm_expired) + .checked_add(self.objects_failed)? + .checked_add(self.skipped_objects)? + .checked_add(self.skipped_new_versions)? + .checked_add(self.skipped_ilm_expired) } pub(crate) fn refresh_progress_percentage(&mut self) { + if self.ledger_complete { + self.progress_state = HealProgressState::Completed; + self.progress_percentage = 100.0; + return; + } + if self.counter_unknown { + self.progress_state = HealProgressState::Unknown; + self.progress_percentage = 0.0; + return; + } + if !self.baseline_known { + self.progress_state = HealProgressState::Indeterminate; + self.progress_percentage = 0.0; + self.estimated_completion_time = None; + return; + } if self.objects_total_size > 0 { self.progress_percentage = ((self.bytes_processed as f64 / self.objects_total_size as f64) * 100.0).min(100.0); + self.progress_percentage = self.progress_percentage.min(99.999); + self.progress_state = HealProgressState::Running; return; } if self.objects_total_count > 0 { - let completed = self.completed_for_baseline(); + let Some(completed) = self.completed_for_baseline() else { + self.progress_state = HealProgressState::Unknown; + self.progress_percentage = 0.0; + return; + }; self.progress_percentage = ((completed as f64 / self.objects_total_count as f64) * 100.0).min(100.0); + self.progress_percentage = self.progress_percentage.min(99.999); + self.progress_state = HealProgressState::Running; return; } - - let total = self - .objects_scanned - .saturating_add(self.objects_healed) - .saturating_add(self.objects_failed); - if total > 0 { - self.progress_percentage = (self.objects_healed as f64 / total as f64) * 100.0; + if self.baseline_known { + self.progress_state = HealProgressState::Running; + self.progress_percentage = 0.0; + return; } + self.progress_state = HealProgressState::Indeterminate; + self.progress_percentage = 0.0; } pub fn set_current_object(&mut self, object: Option) { @@ -125,7 +341,11 @@ impl HealProgress { self.estimated_completion_time = None; return; }; - if self.is_completed() || !(0.0..100.0).contains(&self.progress_percentage) || self.bytes_processed == 0 { + if self.is_completed() + || self.progress_percentage <= 0.0 + || self.progress_percentage >= 100.0 + || self.bytes_processed == 0 + { self.estimated_completion_time = None; return; } @@ -142,18 +362,39 @@ impl HealProgress { } pub fn is_completed(&self) -> bool { - if self.progress_percentage >= 100.0 { - return true; - } - if self.objects_total_count > 0 || self.objects_total_size > 0 { - return false; - } + self.ledger_complete + } - self.objects_scanned > 0 && self.objects_healed.saturating_add(self.objects_failed) >= self.objects_scanned + /// Mark telemetry unknown while allowing the underlying heal operation to + /// continue. This is used for corrupt/overflowing counters at the + /// observability boundary; it must never turn a successful heal into an + /// execution error. + pub fn mark_unknown(&mut self) { + self.counter_unknown = true; + self.progress_state = HealProgressState::Unknown; + self.ledger_complete = false; + self.progress_percentage = 0.0; + self.estimated_completion_time = None; + self.last_update_time = Some(SystemTime::now()); + } + + /// Mark the object ledger terminal only after the enclosing task has + /// committed all durable resume state and cleanup fences. + pub fn mark_completed(&mut self) { + let telemetry_unknown = self.counter_unknown || self.progress_state == HealProgressState::Unknown; + self.ledger_complete = true; + if !telemetry_unknown { + self.progress_state = HealProgressState::Completed; + } + self.progress_percentage = 100.0; + self.last_update_time = Some(SystemTime::now()); + self.estimated_completion_time = None; } pub fn get_success_rate(&self) -> f64 { - let total = self.objects_healed + self.objects_failed; + let Some(total) = self.objects_healed.checked_add(self.objects_failed) else { + return 0.0; + }; if total > 0 { (self.objects_healed as f64 / total as f64) * 100.0 } else { @@ -162,6 +403,101 @@ impl HealProgress { } } +pub fn aggregate_heal_progress(progresses: impl IntoIterator) -> Option { + let mut snapshot = HealProgress::default(); + let mut found = false; + let mut has_object_sweep = false; + let mut all_object_baselines_known = true; + let mut baseline_generation = None; + let mut baseline_generation_consistent = true; + let mut all_ledgers_complete = true; + let mut counter_overflow = false; + + for progress in progresses { + found = true; + let object_sweep = matches!(progress.kind, HealProgressKind::ObjectSweep); + has_object_sweep |= object_sweep; + all_ledgers_complete &= progress.ledger_complete; + if object_sweep { + all_object_baselines_known &= progress.baseline_known; + match baseline_generation { + None => baseline_generation = Some(progress.baseline_generation), + Some(generation) => baseline_generation_consistent &= generation == progress.baseline_generation, + } + } + counter_overflow |= progress.counter_unknown || matches!(progress.progress_state, HealProgressState::Unknown); + for (target, value) in [ + (&mut snapshot.objects_scanned, progress.objects_scanned), + (&mut snapshot.objects_healed, progress.objects_healed), + (&mut snapshot.objects_failed, progress.objects_failed), + (&mut snapshot.skipped_objects, progress.skipped_objects), + (&mut snapshot.skipped_new_versions, progress.skipped_new_versions), + (&mut snapshot.skipped_ilm_expired, progress.skipped_ilm_expired), + (&mut snapshot.objects_total_count, progress.objects_total_count), + (&mut snapshot.objects_total_size, progress.objects_total_size), + (&mut snapshot.bytes_processed, progress.bytes_processed), + (&mut snapshot.stage_current, progress.stage_current), + (&mut snapshot.stage_total, progress.stage_total), + ] { + match target.checked_add(value) { + Some(sum) => *target = sum, + None => { + *target = u64::MAX; + counter_overflow = true; + } + } + } + snapshot.start_time = match (snapshot.start_time, progress.start_time) { + (Some(current), Some(next)) => Some(current.min(next)), + (None, next) => next, + (current, None) => current, + }; + snapshot.last_update_time = match (snapshot.last_update_time, progress.last_update_time) { + (Some(current), Some(next)) => Some(current.max(next)), + (None, next) => next, + (current, None) => current, + }; + if progress.current_object.is_some() { + snapshot.current_object = progress.current_object; + } + } + + if !found { + return None; + } + + snapshot.kind = if has_object_sweep { + HealProgressKind::ObjectSweep + } else { + HealProgressKind::Stage + }; + snapshot.baseline_known = has_object_sweep && all_object_baselines_known && baseline_generation_consistent; + snapshot.baseline_generation = if snapshot.baseline_known && baseline_generation_consistent { + baseline_generation.flatten() + } else { + None + }; + snapshot.ledger_complete = all_ledgers_complete; + snapshot.counter_unknown = counter_overflow; + if counter_overflow { + snapshot.progress_state = HealProgressState::Unknown; + snapshot.progress_percentage = if snapshot.ledger_complete { 100.0 } else { 0.0 }; + } else if snapshot.ledger_complete { + snapshot.progress_state = HealProgressState::Completed; + snapshot.progress_percentage = 100.0; + } else if has_object_sweep { + snapshot.refresh_progress_percentage(); + } else if snapshot.stage_total == 0 { + snapshot.progress_state = HealProgressState::Indeterminate; + snapshot.progress_percentage = 0.0; + } else { + snapshot.progress_state = HealProgressState::Running; + snapshot.progress_percentage = ((snapshot.stage_current as f64 / snapshot.stage_total as f64) * 100.0).min(99.999); + } + snapshot.refresh_estimated_completion_time(); + Some(snapshot) +} + #[derive(Debug, Clone, Serialize, Deserialize)] pub struct HealStatistics { /// Total heal tasks @@ -230,6 +566,7 @@ mod tests { assert_eq!(progress.objects_scanned, 0); assert_eq!(progress.objects_healed, 0); assert_eq!(progress.objects_failed, 0); + assert_eq!(progress.skipped_objects, 0); assert_eq!(progress.skipped_new_versions, 0); assert_eq!(progress.skipped_ilm_expired, 0); assert_eq!(progress.objects_total_count, 0); @@ -250,10 +587,8 @@ mod tests { assert_eq!(progress.objects_healed, 8); assert_eq!(progress.objects_failed, 2); assert_eq!(progress.bytes_processed, 1024); - // Progress percentage should be calculated based on healed/total - // total = scanned + healed + failed = 10 + 8 + 2 = 20 - // healed/total = 8/20 = 0.4 = 40% - assert!((progress.progress_percentage - 40.0).abs() < 0.001); + assert_eq!(progress.progress_state, HealProgressState::Indeterminate); + assert_eq!(progress.progress_percentage, 0.0); assert!(progress.last_update_time.is_some()); } @@ -262,7 +597,8 @@ mod tests { let mut progress = HealProgress::new(); progress.start_time = Some(SystemTime::now() - Duration::from_secs(10)); - progress.update_progress(100, 25, 0, 4096); + progress.set_total_baseline(100, 16384); + progress.update_progress(25, 25, 0, 4096); let eta = progress .estimated_completion_time @@ -275,7 +611,7 @@ mod tests { let mut progress = HealProgress::new(); progress.set_total_baseline(10, 8192); - progress.update_progress(100, 25, 0, 4096); + progress.update_progress(25, 25, 0, 4096); assert!((progress.progress_percentage - 50.0).abs() < 0.001); } @@ -285,7 +621,7 @@ mod tests { let mut progress = HealProgress::new(); progress.set_total_baseline(10, 0); - progress.update_progress(100, 3, 2, 0); + progress.update_progress(5, 3, 2, 0); assert!((progress.progress_percentage - 50.0).abs() < 0.001); } @@ -295,7 +631,7 @@ mod tests { let mut progress = HealProgress::new(); progress.set_total_baseline(10, 0); - progress.update_progress(100, 3, 2, 0); + progress.update_progress(5, 3, 2, 0); progress.record_skipped_new_version(); assert_eq!(progress.skipped_new_versions, 1); @@ -336,7 +672,8 @@ mod tests { fn test_heal_progress_update_progress_all_healed() { let mut progress = HealProgress::new(); // When scanned=0, healed=10, failed=0: total=10, progress = 10/10 = 100% - progress.update_progress(0, 10, 0, 2048); + progress.update_progress(10, 10, 0, 2048); + progress.mark_completed(); // All healed, should be 100% assert!((progress.progress_percentage - 100.0).abs() < 0.001); @@ -394,6 +731,7 @@ mod tests { assert_eq!(json["objectsScanned"], 10); assert_eq!(json["objectsHealed"], 8); assert_eq!(json["objectsFailed"], 2); + assert_eq!(json["skippedObjects"], 0); assert_eq!(json["skippedNewVersions"], 0); assert_eq!(json["skippedIlmExpired"], 0); assert_eq!(json["bytesProcessed"], 1024); @@ -405,6 +743,7 @@ mod tests { fn test_heal_progress_is_completed_by_percentage() { let mut progress = HealProgress::new(); progress.update_progress(10, 10, 0, 1024); + progress.mark_completed(); assert!(progress.is_completed()); } @@ -415,7 +754,7 @@ mod tests { progress.objects_scanned = 10; progress.objects_healed = 8; progress.objects_failed = 2; - // healed + failed = 8 + 2 = 10 >= scanned = 10 + progress.mark_completed(); assert!(progress.is_completed()); } @@ -455,6 +794,108 @@ mod tests { assert!((progress.get_success_rate() - 100.0).abs() < 0.001); } + #[test] + fn single_object_progress_reaches_terminal_100() { + let mut progress = HealProgress::new(); + progress.update_object_progress(1, 1, 0, 0, 128); + assert!(!progress.is_completed()); + progress.mark_completed(); + assert!(progress.is_completed()); + assert_eq!(progress.progress_percentage, 100.0); + } + + #[test] + fn progress_without_baseline_is_indeterminate() { + let mut progress = HealProgress::new(); + progress.update_object_progress(1, 1, 0, 0, 128); + assert_eq!(progress.progress_state, HealProgressState::Indeterminate); + assert_eq!(progress.progress_percentage, 0.0); + assert!(progress.estimated_completion_time.is_none()); + } + + #[test] + fn progress_retry_is_exactly_once() { + let mut progress = HealProgress::new(); + progress.set_total_baseline(1, 128); + progress.update_object_progress(1, 1, 0, 0, 128); + progress.update_object_progress(1, 1, 0, 0, 128); + assert_eq!(progress.objects_scanned, 1); + assert_eq!(progress.objects_healed, 1); + assert_eq!(progress.bytes_processed, 128); + } + + #[test] + fn progress_never_triggers_cleanup_before_terminal_ledger_empty() { + let mut progress = HealProgress::new(); + progress.progress_percentage = 100.0; + assert!(!progress.is_completed()); + progress.mark_completed(); + assert!(progress.is_completed()); + } + + #[test] + fn progress_counter_overflow_is_marked_unknown_without_aborting_completed_heal() { + let mut progress = HealProgress::new(); + progress.update_object_progress(u64::MAX, u64::MAX, 1, 0, 0); + assert_eq!(progress.progress_state, HealProgressState::Unknown); + progress.mark_completed(); + assert!(progress.is_completed()); + assert_eq!(progress.progress_state, HealProgressState::Unknown); + + let aggregate = aggregate_heal_progress([progress]).expect("progress should aggregate"); + assert!(aggregate.ledger_complete); + assert!(aggregate.counter_unknown); + assert_eq!(aggregate.progress_state, HealProgressState::Unknown); + assert_eq!(aggregate.progress_percentage, 100.0); + } + + #[test] + fn aggregate_rejects_mixed_baseline_generations() { + let progress = |generation| HealProgress { + kind: HealProgressKind::ObjectSweep, + objects_scanned: 5, + objects_total_count: 10, + progress_state: HealProgressState::Running, + baseline_generation: Some(generation), + baseline_known: true, + ..Default::default() + }; + + let aggregate = aggregate_heal_progress([progress(1), progress(2)]).expect("progress should aggregate"); + assert!(!aggregate.baseline_known); + assert_eq!(aggregate.baseline_generation, None); + assert_eq!(aggregate.progress_state, HealProgressState::Indeterminate); + assert_eq!(aggregate.progress_percentage, 0.0); + } + + #[test] + fn aggregate_accepts_multiple_sets_from_one_snapshot_generation() { + let progress = |objects_scanned| HealProgress { + kind: HealProgressKind::ObjectSweep, + objects_scanned, + objects_total_count: 10, + progress_state: HealProgressState::Running, + baseline_generation: Some(7), + baseline_known: true, + ..Default::default() + }; + + let aggregate = aggregate_heal_progress([progress(5), progress(3)]).expect("progress should aggregate"); + assert!(aggregate.baseline_known); + assert_eq!(aggregate.baseline_generation, Some(7)); + } + + #[test] + fn stage_updates_do_not_double_count_object_outcomes() { + let mut progress = HealProgress::new(); + progress.update_object_progress(2, 1, 0, 1, 256); + progress.update_stage(3, 4); + assert_eq!(progress.kind, HealProgressKind::ObjectSweep); + assert_eq!(progress.objects_scanned, 2); + assert_eq!(progress.objects_healed, 1); + assert_eq!(progress.skipped_objects, 1); + } + #[test] fn test_heal_statistics_new() { let stats = HealStatistics::new(); diff --git a/crates/heal/src/heal/resume.rs b/crates/heal/src/heal/resume.rs index b19a2090c..19d9522ae 100644 --- a/crates/heal/src/heal/resume.rs +++ b/crates/heal/src/heal/resume.rs @@ -32,7 +32,7 @@ mod gc; mod replacement; mod utils; -pub use checkpoint::{CheckpointManager, ResumeCheckpoint}; +pub use checkpoint::{CheckpointManager, CheckpointObjectOutcome, CheckpointObjectOutcomeRecord, ResumeCheckpoint}; pub(crate) use gc::ResumeGc; pub(crate) use replacement::replacement_target_identities_match; use replacement::replacement_targets_match_identities; @@ -343,6 +343,12 @@ pub struct ResumeState { pub failed_objects: u64, /// skipped objects pub skipped_objects: u64, + /// Terminal versions skipped because they were newer than the heal start. + #[serde(default)] + pub skipped_new_versions: u64, + /// Terminal versions handed to lifecycle expiry. + #[serde(default)] + pub skipped_ilm_expired: u64, /// current bucket pub current_bucket: Option, /// current object @@ -357,6 +363,24 @@ pub struct ResumeState { pub retry_count: u32, /// max retries pub max_retries: u32, + /// Bytes accounted by the object ledger; additive for old snapshots. + #[serde(default)] + pub processed_bytes: u64, + /// Total bytes from a complete usage snapshot, when available. + #[serde(default)] + pub total_bytes: u64, + /// Generation of the usage snapshot used for the baseline. + #[serde(default)] + pub baseline_generation: Option, + /// Whether the usage baseline is known. Missing in old snapshots means + /// indeterminate rather than a measured zero baseline. + #[serde(default)] + pub baseline_known: bool, + /// Persistent telemetry fence for counter/byte overflow or corruption. + /// It must survive a restart so a saturated snapshot is never presented as + /// a measured percentage on the next resume. + #[serde(default)] + pub counter_unknown: bool, } impl ResumeState { @@ -380,6 +404,8 @@ impl ResumeState { successful_objects: 0, failed_objects: 0, skipped_objects: 0, + skipped_new_versions: 0, + skipped_ilm_expired: 0, current_bucket: None, current_object: None, completed_buckets: Vec::new(), @@ -387,6 +413,11 @@ impl ResumeState { error_message: None, retry_count: 0, max_retries: 3, + processed_bytes: 0, + total_bytes: 0, + baseline_generation: None, + baseline_known: false, + counter_unknown: false, } } @@ -415,6 +446,39 @@ impl ResumeState { self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(); } + pub fn update_progress_with_bytes( + &mut self, + processed: u64, + successful: u64, + failed: u64, + skipped: u64, + processed_bytes: u64, + ) { + self.update_progress(processed, successful, failed, skipped); + self.processed_bytes = processed_bytes; + } + + pub fn set_skipped_version_counts(&mut self, new_versions: u64, ilm_expired: u64) { + self.skipped_new_versions = new_versions; + self.skipped_ilm_expired = ilm_expired; + self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(); + } + + pub fn set_progress_baseline(&mut self, total_objects: u64, total_bytes: u64, generation: Option) { + self.total_objects = total_objects; + self.total_bytes = total_bytes; + self.baseline_generation = generation; + // This method is called only after a complete usage snapshot has been + // validated. A complete but empty snapshot is still a known baseline. + self.baseline_known = true; + self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(); + } + + pub fn mark_counter_unknown(&mut self) { + self.counter_unknown = true; + self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(); + } + pub fn set_current_item(&mut self, bucket: Option, object: Option) { self.current_bucket = bucket; self.current_object = object; @@ -440,6 +504,7 @@ impl ResumeState { if let Some(pos) = self.pending_buckets.iter().position(|b| b == bucket) { self.pending_buckets.remove(pos); } + self.resume_cursor = None; self.last_update = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(); } @@ -457,6 +522,10 @@ impl ResumeState { self.successful_objects = 0; self.failed_objects = 0; self.skipped_objects = 0; + self.skipped_new_versions = 0; + self.skipped_ilm_expired = 0; + self.processed_bytes = 0; + self.counter_unknown = false; self.completed = false; // A retry re-scans every bucket from the beginning, so the version // cursor must be cleared too — otherwise the retry would resume mid-scan. @@ -479,14 +548,28 @@ impl ResumeState { } pub fn get_progress_percentage(&self) -> f64 { + if self.completed { + return 100.0; + } + if self.counter_unknown { + return 0.0; + } + if !self.baseline_known { + return 0.0; + } + if self.total_bytes > 0 { + return ((self.processed_bytes as f64 / self.total_bytes as f64) * 100.0).min(99.999); + } if self.total_objects == 0 { return 0.0; } - (self.processed_objects as f64 / self.total_objects as f64) * 100.0 + ((self.processed_objects as f64 / self.total_objects as f64) * 100.0).min(99.999) } pub fn get_success_rate(&self) -> f64 { - let total = self.successful_objects + self.failed_objects; + let Some(total) = self.successful_objects.checked_add(self.failed_objects) else { + return 0.0; + }; if total == 0 { return 0.0; } @@ -757,6 +840,14 @@ impl ResumeManager { state.successful_objects = 0; state.failed_objects = 0; state.skipped_objects = 0; + state.skipped_new_versions = 0; + state.skipped_ilm_expired = 0; + state.processed_bytes = 0; + state.total_objects = 0; + state.total_bytes = 0; + state.baseline_generation = None; + state.baseline_known = false; + state.counter_unknown = false; state.completed = false; state.completed_buckets.clear(); state.schema_version = CURRENT_RESUME_SCHEMA; @@ -841,6 +932,41 @@ impl ResumeManager { self.save_state_throttled().await } + pub async fn update_progress_with_bytes( + &self, + processed: u64, + successful: u64, + failed: u64, + skipped: u64, + processed_bytes: u64, + ) -> Result<()> { + let mut state = self.state.write().await; + state.update_progress_with_bytes(processed, successful, failed, skipped, processed_bytes); + drop(state); + self.save_state_throttled().await + } + + pub async fn set_progress_baseline(&self, total_objects: u64, total_bytes: u64, generation: Option) -> Result<()> { + let mut state = self.state.write().await; + state.set_progress_baseline(total_objects, total_bytes, generation); + drop(state); + self.save_state_throttled().await + } + + pub async fn mark_counter_unknown(&self) -> Result<()> { + let mut state = self.state.write().await; + state.mark_counter_unknown(); + drop(state); + self.save_state().await + } + + pub async fn set_skipped_version_counts(&self, new_versions: u64, ilm_expired: u64) -> Result<()> { + let mut state = self.state.write().await; + state.set_skipped_version_counts(new_versions, ilm_expired); + drop(state); + self.save_state_throttled().await + } + /// Set current item. Called once per healed object, so persistence is /// throttled: the in-memory state always updates, but the snapshot is only /// written every `PERSIST_EVERY_MUTATIONS` calls or `PERSIST_INTERVAL`. @@ -885,7 +1011,7 @@ impl ResumeManager { let mut state = self.state.write().await; state.complete_bucket(bucket); drop(state); - self.save_state_throttled().await + self.save_state().await } /// mark task completed diff --git a/crates/heal/src/heal/resume/checkpoint.rs b/crates/heal/src/heal/resume/checkpoint.rs index 18e159386..b3f097c9f 100644 --- a/crates/heal/src/heal/resume/checkpoint.rs +++ b/crates/heal/src/heal/resume/checkpoint.rs @@ -34,11 +34,31 @@ const EVENT_HEAL_CHECKPOINT_STATE: &str = "heal_checkpoint_state"; const RESUME_CHECKPOINT_DIGEST_FILE: &str = "ahm_checkpoint.sha256"; const CHECKPOINT_PER_VERSION_SCHEMA: u32 = 5; -/// Current on-disk schema version for `ResumeCheckpoint`. Same rationale as -/// `CURRENT_RESUME_SCHEMA`: pre-per-version dedup identities are not comparable -/// to the new `compose_key` identities, so a stale checkpoint is discarded. +/// Current on-disk schema version for `ResumeCheckpoint`. Schema 5 could +/// persist dedup identities without the aggregate counters needed to restore +/// them safely, so stale checkpoints are discarded and replayed. pub(super) const CURRENT_CHECKPOINT_SCHEMA: u32 = 6; +#[derive(Debug, Clone, Copy)] +pub enum CheckpointObjectOutcome { + Processed, + Failed, + Skipped, +} + +#[derive(Debug)] +pub struct CheckpointObjectOutcomeRecord { + pub object: String, + pub outcome: CheckpointObjectOutcome, + pub successful: u64, + pub failed: u64, + pub skipped: u64, + pub bytes: u64, + pub skipped_new_versions: u64, + pub skipped_ilm_expired: u64, + pub counter_unknown: bool, +} + /// resume checkpoint #[derive(Debug, Clone, Serialize, Deserialize)] pub struct ResumeCheckpoint { @@ -62,6 +82,30 @@ pub struct ResumeCheckpoint { pub failed_objects: HashSet, /// skipped objects pub skipped_objects: HashSet, + /// Aggregate object ledger counters restored alongside the dedup sets. + #[serde(default)] + pub successful_objects: u64, + #[serde(default)] + pub failed_object_count: u64, + #[serde(default)] + pub skipped_object_count: u64, + #[serde(default)] + pub skipped_new_versions: u64, + #[serde(default)] + pub skipped_ilm_expired: u64, + #[serde(default)] + pub processed_bytes: u64, + #[serde(default)] + pub total_objects: u64, + #[serde(default)] + pub total_bytes: u64, + #[serde(default)] + pub baseline_generation: Option, + #[serde(default)] + pub baseline_known: bool, + /// Persistent telemetry fence for counter/byte overflow or corruption. + #[serde(default)] + pub counter_unknown: bool, /// Integrity digest over the checkpoint with this field set to `None`. /// Keeping it in the checkpoint makes the payload and its authentication /// record one CAS generation instead of two independently-written files. @@ -80,6 +124,17 @@ impl ResumeCheckpoint { processed_objects: HashSet::new(), failed_objects: HashSet::new(), skipped_objects: HashSet::new(), + successful_objects: 0, + failed_object_count: 0, + skipped_object_count: 0, + skipped_new_versions: 0, + skipped_ilm_expired: 0, + processed_bytes: 0, + total_objects: 0, + total_bytes: 0, + baseline_generation: None, + baseline_known: false, + counter_unknown: false, integrity_digest: None, } } @@ -102,6 +157,34 @@ impl ResumeCheckpoint { self.skipped_objects.insert(object); } + pub fn update_progress(&mut self, successful: u64, failed: u64, skipped: u64, bytes: u64) { + self.successful_objects = successful; + self.failed_object_count = failed; + self.skipped_object_count = skipped; + self.processed_bytes = bytes; + } + + pub fn set_progress_baseline(&mut self, total_objects: u64, total_bytes: u64, generation: Option) { + self.total_objects = total_objects; + self.total_bytes = total_bytes; + self.baseline_generation = generation; + // The caller has already validated that this is a complete snapshot; + // preserve the distinction between a known empty scope and an old + // checkpoint that omitted all baseline fields. + self.baseline_known = true; + } + + pub fn mark_counter_unknown(&mut self) { + self.counter_unknown = true; + self.checkpoint_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(); + } + + pub fn set_skipped_version_counts(&mut self, new_versions: u64, ilm_expired: u64) { + self.skipped_new_versions = new_versions; + self.skipped_ilm_expired = ilm_expired; + self.checkpoint_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap_or_default().as_secs(); + } + /// Advance past a fully-processed page: objects below `object_index` are /// skipped by position on resume, so the per-object sets no longer need /// their entries and would otherwise grow with the whole bucket. @@ -118,6 +201,17 @@ impl ResumeCheckpoint { self.update_position(0, 0); self.processed_objects.clear(); self.skipped_objects.clear(); + self.successful_objects = 0; + self.failed_object_count = 0; + self.skipped_object_count = 0; + self.skipped_new_versions = 0; + self.skipped_ilm_expired = 0; + self.processed_bytes = 0; + self.total_objects = 0; + self.total_bytes = 0; + self.baseline_generation = None; + self.baseline_known = false; + self.counter_unknown = false; self.failed_objects.clear(); } } @@ -275,10 +369,9 @@ impl CheckpointManager { }); } - // A checkpoint from an older schema stored latest-only dedup identities - // that are not comparable to the new per-version `compose_key` - // identities. Discard the stale sets and position, then stamp the - // current schema so the scan restarts cleanly. + // Older checkpoints can contain identities that are not comparable to + // the current keys or lack their corresponding aggregate counters. + // Discard the stale sets and position so the scan restarts cleanly. if checkpoint.schema_version > CURRENT_CHECKPOINT_SCHEMA { Self::block_invalid_snapshot(&disk, task_id).await; return Err(Error::TaskExecutionFailed { @@ -341,6 +434,17 @@ impl CheckpointManager { checkpoint.processed_objects.clear(); checkpoint.failed_objects.clear(); checkpoint.skipped_objects.clear(); + checkpoint.successful_objects = 0; + checkpoint.failed_object_count = 0; + checkpoint.skipped_object_count = 0; + checkpoint.skipped_new_versions = 0; + checkpoint.skipped_ilm_expired = 0; + checkpoint.processed_bytes = 0; + checkpoint.total_objects = 0; + checkpoint.total_bytes = 0; + checkpoint.baseline_generation = None; + checkpoint.baseline_known = false; + checkpoint.counter_unknown = false; checkpoint.current_bucket_index = 0; checkpoint.current_object_index = 0; } @@ -383,7 +487,7 @@ impl CheckpointManager { self.save_checkpoint_throttled().await } - /// Advance past a completed page and prune the per-object sets, then persist. + /// Persist a completed page position while retaining its identities. pub async fn complete_page(&self, bucket_index: usize, object_index: usize) -> Result<()> { let mut checkpoint = self.checkpoint.write().await; checkpoint.complete_page(bucket_index, object_index); @@ -391,6 +495,35 @@ impl CheckpointManager { self.save_checkpoint_throttled().await } + /// Persist the page position while retaining identities until the resume + /// cursor is durable. + pub async fn advance_page(&self, bucket_index: usize, object_index: usize) -> Result<()> { + let mut checkpoint = self.checkpoint.write().await; + checkpoint.update_position(bucket_index, object_index); + drop(checkpoint); + self.save_checkpoint().await + } + + /// Remove the previous page's dedup identities only after its resume cursor + /// has been durably exposed. + pub async fn prune_completed_page(&self) -> Result<()> { + let mut checkpoint = self.checkpoint.write().await; + checkpoint.processed_objects.clear(); + checkpoint.skipped_objects.clear(); + checkpoint.failed_objects.clear(); + drop(checkpoint); + self.save_checkpoint().await + } + + /// Advance to the next bucket and clear the final page identities after the + /// resume state has durably recorded the completed bucket. + pub async fn complete_bucket(&self, next_bucket_index: usize) -> Result<()> { + let mut checkpoint = self.checkpoint.write().await; + checkpoint.complete_page(next_bucket_index, 0); + drop(checkpoint); + self.save_checkpoint().await + } + /// Reset the checkpoint to the start of the scan for a retry, then persist. pub async fn reset_for_retry(&self) -> Result<()> { let mut checkpoint = self.checkpoint.write().await; @@ -425,6 +558,62 @@ impl CheckpointManager { self.save_checkpoint_if_due().await } + /// Atomically persist an object's dedup identity with its aggregate result. + pub async fn record_object_outcome(&self, record: CheckpointObjectOutcomeRecord) -> Result<()> { + let CheckpointObjectOutcomeRecord { + object, + outcome, + successful, + failed, + skipped, + bytes, + skipped_new_versions, + skipped_ilm_expired, + counter_unknown, + } = record; + let mut checkpoint = self.checkpoint.write().await; + match outcome { + CheckpointObjectOutcome::Processed => checkpoint.add_processed_object(object), + CheckpointObjectOutcome::Failed => checkpoint.add_failed_object(object), + CheckpointObjectOutcome::Skipped => checkpoint.add_skipped_object(object), + } + checkpoint.update_progress(successful, failed, skipped, bytes); + checkpoint.set_skipped_version_counts(skipped_new_versions, skipped_ilm_expired); + if counter_unknown { + checkpoint.mark_counter_unknown(); + } + drop(checkpoint); + self.save_checkpoint_if_due().await + } + + pub async fn update_progress(&self, successful: u64, failed: u64, skipped: u64, bytes: u64) -> Result<()> { + let mut checkpoint = self.checkpoint.write().await; + checkpoint.update_progress(successful, failed, skipped, bytes); + drop(checkpoint); + self.save_checkpoint_if_due().await + } + + pub async fn set_progress_baseline(&self, total_objects: u64, total_bytes: u64, generation: Option) -> Result<()> { + let mut checkpoint = self.checkpoint.write().await; + checkpoint.set_progress_baseline(total_objects, total_bytes, generation); + drop(checkpoint); + self.save_checkpoint_throttled().await + } + + pub async fn mark_counter_unknown(&self) -> Result<()> { + let mut checkpoint = self.checkpoint.write().await; + checkpoint.mark_counter_unknown(); + drop(checkpoint); + self.save_checkpoint().await + } + + pub async fn set_skipped_version_counts(&self, new_versions: u64, ilm_expired: u64) -> Result<()> { + let mut checkpoint = self.checkpoint.write().await; + checkpoint.set_skipped_version_counts(new_versions, ilm_expired); + drop(checkpoint); + self.save_checkpoint_throttled().await + } + async fn save_checkpoint_if_due(&self) -> Result<()> { let should_save = self.throttle.lock().map(|mut throttle| throttle.record()).unwrap_or(true); if !should_save { diff --git a/crates/heal/src/heal/resume/tests.rs b/crates/heal/src/heal/resume/tests.rs index fd76c9924..73d379b04 100644 --- a/crates/heal/src/heal/resume/tests.rs +++ b/crates/heal/src/heal/resume/tests.rs @@ -1296,6 +1296,7 @@ async fn test_resume_state_progress() { assert_eq!(progress, 0.0); // total_objects is 0 state.total_objects = 100; + state.baseline_known = true; let progress = state.get_progress_percentage(); assert_eq!(progress, 10.0); } @@ -1475,6 +1476,40 @@ fn test_checkpoint_object_sets_dedupe_and_prune() { assert!(checkpoint.failed_objects.is_empty()); } +#[tokio::test] +async fn checkpoint_page_commit_keeps_ledger_until_cursor_is_durable() { + let (_temp_dir, disk) = schema_test_disk().await; + let task_id = ResumeUtils::generate_task_id(); + let checkpoint = CheckpointManager::new(disk.clone(), task_id.clone()).await.unwrap(); + + checkpoint + .record_object_outcome(CheckpointObjectOutcomeRecord { + object: "bucket/object:v1".to_string(), + outcome: CheckpointObjectOutcome::Processed, + successful: 1, + failed: 0, + skipped: 0, + bytes: 128, + skipped_new_versions: 0, + skipped_ilm_expired: 0, + counter_unknown: false, + }) + .await + .unwrap(); + checkpoint.advance_page(0, 1).await.unwrap(); + + let reloaded = CheckpointManager::load_from_disk(disk.clone(), &task_id).await.unwrap(); + let snapshot = reloaded.get_checkpoint().await; + assert_eq!(snapshot.current_object_index, 1); + assert_eq!(snapshot.successful_objects, 1); + assert_eq!(snapshot.processed_bytes, 128); + assert!(snapshot.processed_objects.contains("bucket/object:v1")); + + checkpoint.prune_completed_page().await.unwrap(); + let reloaded = CheckpointManager::load_from_disk(disk, &task_id).await.unwrap(); + assert!(reloaded.get_checkpoint().await.processed_objects.is_empty()); +} + #[test] fn test_checkpoint_loads_legacy_vec_format() { // Checkpoints written before the HashSet migration stored the object @@ -1568,14 +1603,14 @@ async fn test_resumestate_schema_v0_discarded_on_load() { } #[tokio::test] -async fn test_checkpoint_schema_v4_discarded_on_load() { +async fn test_checkpoint_schema_v5_discarded_on_load() { let (temp_dir, disk) = schema_test_disk().await; - // The previous checkpoint schema is unsafe once its paired resume - // state is discarded: retaining either position would skip work. + // Schema v5 can persist failed identities without the aggregate counters + // that make those identities safe to deduplicate after an upgrade. let task_id = "00000000-0000-4000-8000-000000000002"; let legacy = r#"{ - "schema_version": 4, + "schema_version": 5, "task_id": "00000000-0000-4000-8000-000000000002", "checkpoint_time": 1700000000, "current_bucket_index": 2, @@ -1665,6 +1700,120 @@ async fn current_normal_resume_schema_preserves_progress() { temp_dir.close().expect("remove schema test directory"); } +#[test] +fn progress_checkpoint_restores_bytes_and_generation() { + let mut checkpoint = ResumeCheckpoint::new("progress-checkpoint".to_string()); + checkpoint.set_progress_baseline(9, 4096, Some(77)); + checkpoint.update_progress(4, 1, 2, 2048); + checkpoint.set_skipped_version_counts(3, 1); + checkpoint.mark_counter_unknown(); + + let restored: ResumeCheckpoint = + serde_json::from_slice(&serde_json::to_vec(&checkpoint).expect("serialize checkpoint")).expect("deserialize checkpoint"); + assert_eq!(restored.processed_bytes, 2048); + assert_eq!(restored.total_objects, 9); + assert_eq!(restored.total_bytes, 4096); + assert_eq!(restored.baseline_generation, Some(77)); + assert!(restored.baseline_known); + assert_eq!(restored.skipped_new_versions, 3); + assert_eq!(restored.skipped_ilm_expired, 1); + assert!(restored.counter_unknown); +} + +#[test] +fn old_progress_schema_migrates_missing_fields_to_unknown() { + let state = ResumeState::new( + "legacy-progress".to_string(), + "erasure_set".to_string(), + "pool_0_set_0".to_string(), + Vec::new(), + ); + let mut value = serde_json::to_value(state).expect("serialize legacy-compatible state"); + let object = value.as_object_mut().expect("state must be an object"); + for field in [ + "processed_bytes", + "total_bytes", + "baseline_generation", + "baseline_known", + "skipped_new_versions", + "skipped_ilm_expired", + ] { + object.remove(field); + } + object.insert("total_objects".to_string(), serde_json::json!(10)); + object.insert("processed_objects".to_string(), serde_json::json!(5)); + let restored: ResumeState = serde_json::from_value(value).expect("deserialize old progress state"); + assert_eq!(restored.processed_bytes, 0); + assert_eq!(restored.total_bytes, 0); + assert_eq!(restored.baseline_generation, None); + assert!(!restored.baseline_known, "missing baseline must remain unknown"); + assert_eq!(restored.get_progress_percentage(), 0.0); + assert_eq!(restored.skipped_new_versions, 0); + assert_eq!(restored.skipped_ilm_expired, 0); +} + +#[test] +fn progress_counter_unknown_survives_resume_round_trip() { + let mut state = ResumeState::new( + "overflow-progress".to_string(), + "erasure_set".to_string(), + "pool_0_set_0".to_string(), + Vec::new(), + ); + state.mark_counter_unknown(); + + let restored: ResumeState = + serde_json::from_slice(&serde_json::to_vec(&state).expect("serialize resume state")).expect("deserialize resume state"); + assert!(restored.counter_unknown); +} + +#[tokio::test] +async fn checkpoint_progress_survives_a_torn_resume_summary_write() { + let (_temp_dir, disk) = schema_test_disk().await; + let task_id = ResumeUtils::generate_task_id(); + let _resume = ResumeManager::new( + disk.clone(), + task_id.clone(), + "erasure_set".to_string(), + "pool_0_set_0".to_string(), + vec!["bucket".to_string()], + ) + .await + .expect("resume state should persist"); + let checkpoint = CheckpointManager::new(disk.clone(), task_id.clone()) + .await + .expect("checkpoint should persist"); + + // This is the ordering used by the erasure-set loop: the checkpoint is + // durable before the summary write. Stop here to model a crash in the + // inter-store window and verify that the recovery authority retains the + // telemetry fence and bytes. + checkpoint + .update_progress(3, 0, 0, 1024) + .await + .expect("checkpoint progress should persist"); + checkpoint.mark_counter_unknown().await.expect("unknown fence should persist"); + checkpoint + .update_position(0, 3) + .await + .expect("checkpoint position should persist"); + + let restored_checkpoint = CheckpointManager::load_from_disk(disk.clone(), &task_id) + .await + .expect("checkpoint should reload") + .get_checkpoint() + .await; + let restored_resume = ResumeManager::load_from_disk(disk, &task_id) + .await + .expect("resume summary should reload") + .get_state() + .await; + assert!(restored_checkpoint.counter_unknown); + assert_eq!(restored_checkpoint.processed_bytes, 1024); + assert_eq!(restored_checkpoint.current_object_index, 3); + assert!(!restored_resume.counter_unknown, "summary is intentionally the torn/older store"); +} + #[tokio::test] async fn future_resume_and_checkpoint_schemas_are_rejected() { let (temp_dir, disk) = schema_test_disk().await; diff --git a/crates/heal/src/heal/storage.rs b/crates/heal/src/heal/storage.rs index de3cd149a..a3e7c0cdf 100644 --- a/crates/heal/src/heal/storage.rs +++ b/crates/heal/src/heal/storage.rs @@ -22,6 +22,7 @@ use serde::{Deserialize, Serialize}; use std::sync::Arc; use tracing::{debug, error, warn}; +use super::progress::stable_generation; use super::storage_api::owner::{EcstoreHealLifecycleExpiryContext, ecstore_load_admin_data_usage_from_backend_cached}; use super::storage_api::storage::{ BucketInfo, BucketOperations, DiskSetSelector, HealOperations as _, ListOperations as _, ObjectIO as _, @@ -34,6 +35,9 @@ pub use super::{HealObjectInfo, HealObjectOptions, HealPutObjReader}; pub struct HealBucketUsageBaseline { pub objects_count: u64, pub bytes: u64, + /// Stable identity of the validated usage snapshot and selected scope. + /// `None` is retained for test/legacy providers that cannot expose one. + pub generation: Option, } pub struct HealLifecycleExpiryContext { @@ -785,11 +789,52 @@ impl HealStorageAPI for ECStoreHealStorage { let mut baseline = HealBucketUsageBaseline::default(); for bucket in buckets { if let Some(usage) = info.buckets_usage.get(bucket) { - baseline.objects_count = baseline.objects_count.saturating_add(usage.objects_count); - baseline.bytes = baseline.bytes.saturating_add(usage.size); + baseline.objects_count = match baseline.objects_count.checked_add(usage.objects_count) { + Some(total) => total, + // A corrupt/overflowing usage snapshot is not a usable + // denominator. Leave progress indeterminate instead of + // turning saturation into a plausible percentage. + None => return Ok(None), + }; + baseline.bytes = match baseline.bytes.checked_add(usage.size) { + Some(total) => total, + None => return Ok(None), + }; } } + let identity = info.snapshot_identity(); + let mut canonical = Vec::new(); + match identity.last_update { + Some(last_update) => { + canonical.push(1); + canonical.extend_from_slice( + &last_update + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_nanos() + .to_be_bytes(), + ); + } + None => canonical.push(0), + } + for value in [identity.scanner_cycle, identity.scanner_epoch] { + match value { + Some(value) => { + canonical.push(1); + canonical.extend_from_slice(&value.to_be_bytes()); + } + None => canonical.push(0), + } + } + let mut scope = buckets.to_vec(); + scope.sort_unstable(); + for bucket in scope { + canonical.extend_from_slice(&(bucket.len() as u64).to_be_bytes()); + canonical.extend_from_slice(bucket.as_bytes()); + } + baseline.generation = Some(stable_generation(&[&canonical])); + Ok(Some(baseline)) } diff --git a/crates/heal/src/heal/task.rs b/crates/heal/src/heal/task.rs index 5a047c4dd..0d142e15d 100644 --- a/crates/heal/src/heal/task.rs +++ b/crates/heal/src/heal/task.rs @@ -649,7 +649,7 @@ impl HealTask { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("skipped: {bucket}/{object}"))); - progress.update_progress(0, 1, 0, 0); + progress.update_stage(1, 1); Ok(()) } @@ -733,7 +733,7 @@ impl HealTask { "Heal object skipped for data usage cache after transient error" ); let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); true } @@ -757,7 +757,7 @@ impl HealTask { ); let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("skipped: {bucket}/{object}"))); - progress.update_progress(4, 4, 0, 0); + progress.update_stage(4, 4); true } @@ -831,6 +831,10 @@ impl HealTask { match &result { Ok(_) => { + // A stage can reach its final step before the durable resume + // ledger and cleanup fences commit. Publish terminal 100 only + // after the enclosing operation has returned success. + self.progress.write().await.mark_completed(); let mut status = self.status.write().await; *status = HealTaskStatus::Completed; demote_to_debug_when!(self.heal_type.is_per_object(), info, target: "rustfs::heal::task", { diff --git a/crates/heal/src/heal/task/heal_bucket.rs b/crates/heal/src/heal/task/heal_bucket.rs index 7c80fa75a..8a4a28476 100644 --- a/crates/heal/src/heal/task/heal_bucket.rs +++ b/crates/heal/src/heal/task/heal_bucket.rs @@ -13,6 +13,7 @@ // limitations under the License. /// bucket/cluster/prefix heal: the recursive bucket-objects sweep and the erasure-set usage baseline use super::*; +use crate::heal::progress::{add_bytes, increment_counter, stable_generation}; impl HealTask { pub(super) async fn heal_bucket(&self, bucket: &str) -> Result<()> { @@ -32,7 +33,7 @@ impl HealTask { { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("bucket: {bucket}"))); - progress.update_progress(0, 3, 0, 0); + progress.update_stage(0, 3); } // Step 1: Check if bucket exists @@ -66,7 +67,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(1, 3, 0, 0); + progress.update_stage(1, 3); } // Step 2: Perform bucket heal using ecstore @@ -122,7 +123,7 @@ impl HealTask { if !self.options.recursive { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } Ok(()) } @@ -142,7 +143,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } Err(Error::TaskExecutionFailed { message: format!("Failed to heal bucket {bucket}: {e}"), @@ -245,6 +246,7 @@ impl HealTask { let mut scanned = 0u64; let mut healed = 0u64; let mut failed = 0u64; + let mut skipped = 0u64; let mut retryable_failed = 0u64; let mut permanent_failed = 0u64; let mut bytes = 0u64; @@ -286,16 +288,14 @@ impl HealTask { let mut retry = Vec::with_capacity(pending.len()); for item in pending { self.check_control_flags().await?; + let mut telemetry_unknown = false; let object = item.name.as_str(); - if retry_attempt == 0 { - scanned = scanned.saturating_add(1); - } { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("{bucket}/{object}"))); - progress.update_progress(scanned, healed, failed, bytes); } + let mut terminal_outcome = true; let error = match self .await_with_control( self.storage @@ -304,13 +304,13 @@ impl HealTask { .await { Ok((result, None)) => { - healed = healed.saturating_add(1); - bytes = bytes.saturating_add(u64::try_from(result.object_size).unwrap_or_default()); + telemetry_unknown |= !increment_counter(&mut healed); + telemetry_unknown |= !add_bytes(&mut bytes, u64::try_from(result.object_size).unwrap_or(u64::MAX)); self.record_result_item(result).await; None } Ok((_, Some(err))) if is_missing_object_dir_heal_result(object, &err) => { - healed = healed.saturating_add(1); + telemetry_unknown |= !increment_counter(&mut healed); debug!( target: "rustfs::heal::task", event = EVENT_HEAL_BUCKET_RESULT, @@ -329,6 +329,7 @@ impl HealTask { if let Some(err) = error { if Self::should_skip_data_usage_cache_heal_error(bucket, object, &err) { + telemetry_unknown |= !increment_counter(&mut skipped); warn!( target: "rustfs::heal::task", event = EVENT_HEAL_BUCKET_RESULT, @@ -342,6 +343,7 @@ impl HealTask { "Heal bucket object repair skipped due to transient metadata error" ); } else if err.is_recoverable_heal() && retry_attempt < MAX_BUCKET_OBJECT_HEAL_RETRIES { + terminal_outcome = false; debug!( target: "rustfs::heal::task", event = EVENT_HEAL_BUCKET_RESULT, @@ -357,7 +359,7 @@ impl HealTask { ); retry.push(item); } else { - failed = failed.saturating_add(1); + telemetry_unknown |= !increment_counter(&mut failed); if err.is_recoverable_heal() { retryable_failed = retryable_failed.saturating_add(1); } else { @@ -383,8 +385,19 @@ impl HealTask { } } + if terminal_outcome { + telemetry_unknown |= !increment_counter(&mut scanned); + } + + if !terminal_outcome { + continue; + } + let mut progress = self.progress.write().await; - progress.update_progress(scanned, healed, failed, bytes); + progress.update_object_progress(scanned, healed, failed, skipped, bytes); + if telemetry_unknown { + progress.mark_unknown(); + } } pending = retry; retry_attempt = retry_attempt.saturating_add(1); @@ -432,6 +445,9 @@ impl HealTask { } pub(super) async fn apply_erasure_set_usage_baseline(&self, buckets: &[String]) -> Result<()> { + if matches!(self.options.scan_mode, HealScanMode::Deep) || matches!(self.source, HealRequestSource::AutoHeal) { + return Ok(()); + } let baseline = match self .await_with_control(self.storage.erasure_set_usage_baseline(buckets)) .await @@ -442,9 +458,18 @@ impl HealTask { Err(_) => return Ok(()), }; - let HealBucketUsageBaseline { objects_count, bytes } = baseline; + let HealBucketUsageBaseline { + objects_count, + bytes, + generation, + } = baseline; + let generation = generation.map(|snapshot_generation| stable_generation(&[&snapshot_generation.to_be_bytes()])); let mut progress = self.progress.write().await; - progress.set_total_baseline(objects_count, bytes); + if let Some(generation) = generation { + progress.set_total_baseline_with_generation(objects_count, bytes, generation); + } else { + progress.set_total_baseline(objects_count, bytes); + } Ok(()) } } diff --git a/crates/heal/src/heal/task/heal_erasure_set.rs b/crates/heal/src/heal/task/heal_erasure_set.rs index 7b25bcba2..d983e9b96 100644 --- a/crates/heal/src/heal/task/heal_erasure_set.rs +++ b/crates/heal/src/heal/task/heal_erasure_set.rs @@ -32,7 +32,7 @@ impl HealTask { { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("erasure_set: {} ({} buckets)", set_disk_id, buckets.len()))); - progress.update_progress(0, 4, 0, 0); + progress.update_stage(0, 4); } let is_auto_replacement = matches!(self.source, HealRequestSource::AutoHeal) && !self.heal_endpoints.is_empty(); @@ -248,7 +248,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(4, 4, 0, 0); + progress.update_stage(4, 4); } return Err(Error::TaskExecutionFailed { message: format!("Failed to heal disk format for {set_disk_id}: {error}"), @@ -304,7 +304,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(4, 4, 0, 0); + progress.update_stage(4, 4); } return Err(Error::TaskExecutionFailed { message: format!("Failed to heal disk format for {set_disk_id}: {e}"), @@ -314,7 +314,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(1, 4, 0, 0); + progress.update_stage(1, 4); } // The rebuilt disks are formatted now: mark them as healing so @@ -343,7 +343,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(2, 4, 0, 0); + progress.update_stage(2, 4); } // Step 3: Heal bucket structure @@ -427,7 +427,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(3, 4, 0, 0); + progress.update_stage(3, 4); } // Step 4: Execute erasure set heal with resume @@ -470,9 +470,7 @@ impl HealTask { }; { - let mut progress = self.progress.write().await; - let bytes_processed = progress.bytes_processed; - progress.update_progress(4, 4, 0, bytes_processed); + self.progress.write().await.update_stage(4, 4); } match result { diff --git a/crates/heal/src/heal/task/heal_metadata.rs b/crates/heal/src/heal/task/heal_metadata.rs index 55f3a87df..3b2129288 100644 --- a/crates/heal/src/heal/task/heal_metadata.rs +++ b/crates/heal/src/heal/task/heal_metadata.rs @@ -32,7 +32,7 @@ impl HealTask { { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("metadata: {bucket}/{object}"))); - progress.update_progress(0, 3, 0, 0); + progress.update_stage(0, 3); } // Step 1: Check if object exists @@ -74,7 +74,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(1, 3, 0, 0); + progress.update_stage(1, 3); } // Step 2: Perform metadata heal using ecstore @@ -122,7 +122,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } return Err(Error::TaskExecutionFailed { message: format!("Failed to heal metadata {bucket}/{object}: {e}"), @@ -145,7 +145,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } self.record_result_item(result).await; Ok(()) @@ -167,7 +167,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } Err(Error::TaskExecutionFailed { message: format!("Failed to heal metadata {bucket}/{object}: {e}"), @@ -194,7 +194,7 @@ impl HealTask { { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("ec_decode: {bucket}/{object}"))); - progress.update_progress(0, 3, 0, 0); + progress.update_stage(0, 3); } // Step 1: Check if object exists @@ -236,7 +236,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(1, 3, 0, 0); + progress.update_stage(1, 3); } // Step 2: Perform EC decode heal using ecstore @@ -284,7 +284,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } return Err(Error::TaskExecutionFailed { message: format!("Failed to heal EC decode {bucket}/{object}: {e}"), @@ -309,7 +309,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, object_size); + progress.update_object_progress(1, 1, 0, 0, object_size); } self.record_result_item(result).await; Ok(()) @@ -331,7 +331,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } Err(Error::TaskExecutionFailed { message: format!("Failed to heal EC decode {bucket}/{object}: {e}"), diff --git a/crates/heal/src/heal/task/heal_object.rs b/crates/heal/src/heal/task/heal_object.rs index 14d908a1d..037bc3d41 100644 --- a/crates/heal/src/heal/task/heal_object.rs +++ b/crates/heal/src/heal/task/heal_object.rs @@ -36,7 +36,7 @@ impl HealTask { { let mut progress = self.progress.write().await; progress.set_current_object(Some(format!("{bucket}/{object}"))); - progress.update_progress(0, 4, 0, 0); + progress.update_stage(0, 4); } // Step 1: Check if object exists and get metadata @@ -132,7 +132,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(1, 3, 0, 0); + progress.update_stage(1, 3); } // Step 2: directly call ecstore to perform heal @@ -187,7 +187,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } return Ok(()); } @@ -207,7 +207,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } if Self::should_return_typed_heal_error(&e) { @@ -249,7 +249,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, object_size); + progress.update_object_progress(1, 1, 0, 0, object_size); } self.record_result_item(result).await; Ok(()) @@ -275,7 +275,7 @@ impl HealTask { ); { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } return Ok(()); } @@ -295,7 +295,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(3, 3, 0, 0); + progress.update_stage(3, 3); } if Self::should_return_typed_heal_error(&e) { @@ -414,7 +414,7 @@ impl HealTask { { let mut progress = self.progress.write().await; - progress.update_progress(4, 4, 0, object_size); + progress.update_object_progress(1, 1, 0, 0, object_size); } self.record_result_item(result).await; Ok(()) diff --git a/crates/heal/src/heal/task/tests.rs b/crates/heal/src/heal/task/tests.rs index f2b442205..4d9635d01 100644 --- a/crates/heal/src/heal/task/tests.rs +++ b/crates/heal/src/heal/task/tests.rs @@ -22,6 +22,7 @@ use std::sync::Mutex; use tempfile::TempDir; use super::super::storage_api::status::BucketInfo; +use crate::heal::progress::{HealProgressState, aggregate_heal_progress}; #[tokio::test] async fn retry_request_carries_remaining_timeout_budget() { @@ -2124,6 +2125,7 @@ async fn erasure_set_heal_applies_usage_baseline_to_progress() { usage_baseline: Mutex::new(Some(HealBucketUsageBaseline { objects_count: 10, bytes: 8, + generation: Some(1), })), ..Default::default() }); @@ -2147,10 +2149,104 @@ async fn erasure_set_heal_applies_usage_baseline_to_progress() { let progress = task.get_progress().await; assert_eq!(progress.objects_total_count, 10); assert_eq!(progress.objects_total_size, 8); + assert!(progress.baseline_generation.is_some()); + assert!(progress.baseline_known); assert_eq!(progress.bytes_processed, 2); assert!((progress.progress_percentage - 25.0).abs() < 0.001); } +#[tokio::test] +async fn erasure_sets_from_one_usage_snapshot_share_baseline_generation() { + let storage: Arc = Arc::new(MockStorage { + usage_baseline: Mutex::new(Some(HealBucketUsageBaseline { + objects_count: 10, + bytes: 8, + generation: Some(7), + })), + ..Default::default() + }); + let buckets = vec!["bucket-a".to_string()]; + let task_for_set = |set_disk_id: &str| { + HealTask::from_request( + HealRequest::new( + HealType::ErasureSet { + buckets: buckets.clone(), + set_disk_id: set_disk_id.to_string(), + }, + HealOptions::default(), + HealPriority::Normal, + ), + storage.clone(), + ) + }; + let first = task_for_set("pool_0_set_0"); + let second = task_for_set("pool_0_set_1"); + + first + .apply_erasure_set_usage_baseline(&buckets) + .await + .expect("first baseline"); + second + .apply_erasure_set_usage_baseline(&buckets) + .await + .expect("second baseline"); + first.progress.write().await.update_object_progress(0, 0, 0, 0, 0); + second.progress.write().await.update_object_progress(0, 0, 0, 0, 0); + let first = first.get_progress().await; + let second = second.get_progress().await; + + let expected_generation = first.baseline_generation; + assert!(expected_generation.is_some()); + assert_eq!(second.baseline_generation, expected_generation); + let aggregate = aggregate_heal_progress([first, second]).expect("aggregate progress"); + assert!(aggregate.baseline_known); + assert_eq!(aggregate.baseline_generation, expected_generation); + assert_eq!(aggregate.progress_state, HealProgressState::Running); +} + +#[tokio::test] +async fn erasure_set_disk_walk_keeps_cluster_usage_baseline_indeterminate() { + for (scan_mode, source) in [ + (HealScanMode::Deep, HealRequestSource::Admin), + (HealScanMode::Normal, HealRequestSource::AutoHeal), + ] { + let temp = TempDir::new().expect("temporary directory should be created"); + let disk = make_resume_disk(&temp).await; + let storage = Arc::new(MockStorage { + resume_disk: Mutex::new(Some(disk)), + usage_baseline: Mutex::new(Some(HealBucketUsageBaseline { + objects_count: 10, + bytes: 8, + generation: Some(1), + })), + ..Default::default() + }); + let mut request = HealRequest::new( + HealType::ErasureSet { + buckets: vec!["bucket-a".to_string()], + set_disk_id: "pool_0_set_0".to_string(), + }, + HealOptions { + scan_mode, + timeout: None, + ..Default::default() + }, + HealPriority::Normal, + ); + request.source = source; + let task = HealTask::from_request(request, storage); + + task.heal_erasure_set(vec!["bucket-a".to_string()], "pool_0_set_0".to_string()) + .await + .expect("erasure set heal should complete"); + + let progress = task.get_progress().await; + assert!(!progress.baseline_known); + assert_eq!(progress.baseline_generation, None); + assert_eq!(progress.progress_state, HealProgressState::Indeterminate); + } +} + #[tokio::test] async fn erasure_set_heal_ignores_usage_baseline_errors() { let temp = TempDir::new().expect("temporary directory should be created"); diff --git a/crates/heal/src/lib.rs b/crates/heal/src/lib.rs index 29444d0f5..a60946229 100644 --- a/crates/heal/src/lib.rs +++ b/crates/heal/src/lib.rs @@ -19,7 +19,7 @@ pub use error::{Error, Result}; pub use heal::{ HealManager, HealOperationsSnapshot, HealOptions, HealPriority, HealPriorityCounts, HealRequest, HealSourceCounts, HealType, channel::HealChannelProcessor, - progress::HealProgress, + progress::{HealProgress, aggregate_heal_progress}, resume::{ReplacementRecoveryRecord, ReplacementRecoveryState, ResumeUtils}, }; use rustfs_concurrency::WorkloadAdmissionSnapshotProvider; diff --git a/crates/protos/src/generated/proto_gen/node_service.rs b/crates/protos/src/generated/proto_gen/node_service.rs index 3885be4a3..3d9fa01d9 100644 --- a/crates/protos/src/generated/proto_gen/node_service.rs +++ b/crates/protos/src/generated/proto_gen/node_service.rs @@ -1215,7 +1215,10 @@ pub struct ScannerActivityResponse { pub dirty_usage_pending: bool, } #[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)] -pub struct BackgroundHealStatusRequest {} +pub struct BackgroundHealStatusRequest { + #[prost(uint32, tag = "1")] + pub protocol_version: u32, +} #[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)] pub struct BackgroundHealStatusResponse { #[prost(bool, tag = "1")] diff --git a/crates/protos/src/lib.rs b/crates/protos/src/lib.rs index ccfb8197d..f4f0c44d8 100644 --- a/crates/protos/src/lib.rs +++ b/crates/protos/src/lib.rs @@ -170,6 +170,7 @@ pub fn internode_rpc_max_message_size() -> usize { pub const HEAL_CONTROL_RPC_MAX_MESSAGE_SIZE: usize = heal_control::RESULT_MAX_SIZE + 1024; pub const HEAL_CONTROL_PROTOCOL_VERSION: u32 = 3; pub const DYNAMIC_CONFIG_PROTOCOL_VERSION: u32 = 1; +pub const BACKGROUND_HEAL_STATUS_PROTOCOL_VERSION: u32 = 2; pub const HEAL_CONTROL_CAPABILITY_PROBE_PREFIX: &[u8] = b"rustfs-heal-control-capability-v3\0"; pub const REMOTE_VERSION_STATE_CAPABILITY_PROBE_PREFIX: &[u8] = b"rustfs-tier-remote-version-state-capability-v1\0"; pub const CROSS_POOL_FENCE_CAPABILITY_PROBE_PREFIX: &[u8] = b"rustfs-cross-pool-fence-capability-v1\0"; @@ -2346,10 +2347,28 @@ pub async fn evict_failed_connection_with_log_level(addr: &str, log_level: Conne #[cfg(test)] mod tests { use super::*; + use prost::Message as _; use std::sync::Mutex; static INTERNODE_RPC_MSGPACK_ONLY_ENV_LOCK: Mutex<()> = Mutex::new(()); + #[derive(Clone, PartialEq, prost::Message)] + struct BackgroundHealStatusRequestV1 {} + + #[test] + fn background_heal_status_request_remains_rolling_upgrade_compatible() { + let current = proto_gen::node_service::BackgroundHealStatusRequest { + protocol_version: BACKGROUND_HEAL_STATUS_PROTOCOL_VERSION, + }; + let encoded = current.encode_to_vec(); + BackgroundHealStatusRequestV1::decode(encoded.as_slice()).expect("v1 server should ignore the version field"); + + let encoded = BackgroundHealStatusRequestV1 {}.encode_to_vec(); + let decoded = proto_gen::node_service::BackgroundHealStatusRequest::decode(encoded.as_slice()) + .expect("v2 server should accept a v1 request"); + assert_eq!(decoded.protocol_version, 0); + } + #[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)] struct CompatPayloadField { message: &'static str, diff --git a/crates/protos/src/node.proto b/crates/protos/src/node.proto index 70ca93565..38812b00f 100644 --- a/crates/protos/src/node.proto +++ b/crates/protos/src/node.proto @@ -846,7 +846,9 @@ message ScannerActivityResponse { bool dirty_usage_pending = 9; } -message BackgroundHealStatusRequest {} +message BackgroundHealStatusRequest { + uint32 protocol_version = 1; +} message BackgroundHealStatusResponse { bool success = 1; diff --git a/rustfs/src/admin/handlers/heal.rs b/rustfs/src/admin/handlers/heal.rs index 9ae59353b..28999fa94 100644 --- a/rustfs/src/admin/handlers/heal.rs +++ b/rustfs/src/admin/handlers/heal.rs @@ -20,7 +20,7 @@ use crate::admin::storage_api::bucket::utils::is_valid_object_prefix; use crate::server::ADMIN_PREFIX; use crate::server::RemoteAddr; use crate::storage::rpc::node_service::heal::{ - HealControlCoordinator, NodeHealProgress, NodeHealStatusSnapshot, capture_node_heal_status, decode_node_heal_status, + HealControlCoordinator, NodeHealStatusSnapshot, capture_node_heal_status, decode_node_heal_status, decode_node_replacement_recovery_status, heal_control_coordinator, heal_topology_fingerprint, }; use bytes::Bytes; @@ -298,14 +298,7 @@ fn background_heal_runtime_state( } } -#[derive(Debug, Serialize)] -#[serde(rename_all = "camelCase")] -struct BackgroundHealProgress { - objects_scanned: u64, - objects_healed: u64, - objects_failed: u64, - bytes_processed: u64, -} +type BackgroundHealProgress = rustfs_heal::HealProgress; #[derive(Debug)] struct ClusterHealStatusSnapshot { @@ -344,17 +337,10 @@ fn add_operations(total: &mut rustfs_heal::HealOperationsSnapshot, next: rustfs_ add_source_counts(&mut total.retrying_by_source, next.retrying_by_source); } -fn add_progress(total: &mut BackgroundHealProgress, next: NodeHealProgress) { - total.objects_scanned = total.objects_scanned.saturating_add(next.objects_scanned); - total.objects_healed = total.objects_healed.saturating_add(next.objects_healed); - total.objects_failed = total.objects_failed.saturating_add(next.objects_failed); - total.bytes_processed = total.bytes_processed.saturating_add(next.bytes_processed); -} - fn aggregate_cluster_heal_status(snapshots: Vec) -> ClusterHealStatusSnapshot { let mut info = BackgroundHealInfo::default(); let mut operations = rustfs_heal::HealOperationsSnapshot::default(); - let mut progress = None; + let mut progress = Vec::new(); let mut any_services_enabled = false; let mut any_initialized = false; @@ -371,18 +357,12 @@ fn aggregate_cluster_heal_status(snapshots: Vec) -> Clus } add_operations(&mut operations, snapshot.operations); if let Some(next) = snapshot.progress { - add_progress( - progress.get_or_insert(BackgroundHealProgress { - objects_scanned: 0, - objects_healed: 0, - objects_failed: 0, - bytes_processed: 0, - }), - next, - ); + progress.push(next); } } + let progress = rustfs_heal::aggregate_heal_progress(progress); + let state = if operations.queue_length > 0 || operations.active_tasks > 0 || operations.retrying_tasks > 0 { HealRuntimeState::Active } else if any_initialized { @@ -2201,10 +2181,19 @@ mod tests { }; let progress = BackgroundHealProgress { + kind: rustfs_heal::heal::progress::HealProgressKind::ObjectSweep, objects_scanned: 7, objects_healed: 3, objects_failed: 1, + skipped_objects: 3, + objects_total_count: 10, + objects_total_size: 8192, bytes_processed: 4096, + progress_percentage: 50.0, + progress_state: rustfs_heal::heal::progress::HealProgressState::Running, + baseline_generation: Some(42), + baseline_known: true, + ..Default::default() }; let encoded = encode_background_heal_status( @@ -2220,7 +2209,14 @@ mod tests { assert_eq!(json["progress"]["objectsScanned"], 7); assert_eq!(json["progress"]["objectsHealed"], 3); assert_eq!(json["progress"]["objectsFailed"], 1); + assert_eq!(json["progress"]["skippedObjects"], 3); + assert_eq!(json["progress"]["objectsTotalCount"], 10); + assert_eq!(json["progress"]["objectsTotalSize"], 8192); assert_eq!(json["progress"]["bytesProcessed"], 4096); + assert_eq!(json["progress"]["progressState"], "running"); + assert_eq!(json["progress"]["baselineGeneration"], 42); + assert_eq!(json["progress"]["baselineKnown"], true); + assert_eq!(json["progress"]["counterUnknown"], false); } #[test] @@ -2242,10 +2238,18 @@ mod tests { ..Default::default() }, Some(NodeHealProgress { + kind: rustfs_heal::heal::progress::HealProgressKind::ObjectSweep, objects_scanned: 3, objects_healed: 1, objects_failed: 0, + skipped_objects: 2, + objects_total_count: 6, + objects_total_size: 400, bytes_processed: 100, + progress_state: rustfs_heal::heal::progress::HealProgressState::Running, + baseline_generation: Some(9), + baseline_known: true, + ..Default::default() }), ); let peer = NodeHealStatusSnapshot::for_test( @@ -2265,10 +2269,17 @@ mod tests { ..Default::default() }, Some(NodeHealProgress { + kind: rustfs_heal::heal::progress::HealProgressKind::ObjectSweep, objects_scanned: 5, objects_healed: 4, objects_failed: 1, + objects_total_count: 4, + objects_total_size: 1600, bytes_processed: 900, + progress_state: rustfs_heal::heal::progress::HealProgressState::Running, + baseline_generation: Some(9), + baseline_known: true, + ..Default::default() }), ); @@ -2287,7 +2298,15 @@ mod tests { assert_eq!(progress.objects_scanned, 8); assert_eq!(progress.objects_healed, 5); assert_eq!(progress.objects_failed, 1); + assert_eq!(progress.skipped_objects, 2); + assert_eq!(progress.objects_total_count, 10); + assert_eq!(progress.objects_total_size, 2000); assert_eq!(progress.bytes_processed, 1000); + assert_eq!(progress.progress_percentage, 50.0); + assert_eq!(progress.progress_state, rustfs_heal::heal::progress::HealProgressState::Running); + assert_eq!(progress.baseline_generation, Some(9)); + assert!(progress.baseline_known); + assert!(!progress.counter_unknown); assert_eq!(peer_first.state, HealRuntimeState::Active); assert_eq!(peer_first.operations, local_first.operations); @@ -2327,6 +2346,7 @@ mod tests { objects_healed: value, objects_failed: value, bytes_processed: value, + ..Default::default() }; let saturated = NodeHealStatusSnapshot::for_test( true, diff --git a/rustfs/src/storage/rpc/node_service.rs b/rustfs/src/storage/rpc/node_service.rs index d8eaadcb4..8c680aa9c 100644 --- a/rustfs/src/storage/rpc/node_service.rs +++ b/rustfs/src/storage/rpc/node_service.rs @@ -1912,7 +1912,7 @@ impl Node for NodeService { async fn background_heal_status( &self, - _request: Request, + request: Request, ) -> Result, Status> { if self.resolve_object_store().is_none() { return Ok(Response::new(BackgroundHealStatusResponse { @@ -1922,7 +1922,7 @@ impl Node for NodeService { })); } let snapshot = heal::capture_node_heal_status(rustfs_scanner::scanner::BackgroundHealInfo::default()).await; - match heal::encode_node_heal_status(&snapshot) { + match heal::encode_node_heal_status(&snapshot, request.into_inner().protocol_version) { Ok(bg_heal_state) => Ok(Response::new(BackgroundHealStatusResponse { success: true, bg_heal_state: bg_heal_state.into(), diff --git a/rustfs/src/storage/rpc/node_service/heal.rs b/rustfs/src/storage/rpc/node_service/heal.rs index 8f796726c..8bbd27572 100644 --- a/rustfs/src/storage/rpc/node_service/heal.rs +++ b/rustfs/src/storage/rpc/node_service/heal.rs @@ -25,7 +25,8 @@ use std::io::Cursor; use super::super::encode_msgpack_map; -const NODE_HEAL_STATUS_VERSION: u8 = 1; +const NODE_HEAL_STATUS_PREVIOUS_VERSION: u8 = 1; +const NODE_HEAL_STATUS_VERSION: u8 = 2; const NODE_HEAL_STATUS_MAX_SIZE: usize = 64 * 1024; const NODE_REPLACEMENT_RECOVERY_STATUS_VERSION: u8 = 1; const NODE_REPLACEMENT_RECOVERY_STATUS_MAX_SIZE: usize = 64 * 1024; @@ -172,13 +173,38 @@ pub(crate) fn heal_topology_fingerprint(endpoint_pools: &EndpointServerPools) -> Ok(hex_simd::encode_to_string(hasher.finalize(), hex_simd::AsciiCase::Lower)) } -#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] +pub(crate) type NodeHealProgress = rustfs_heal::HealProgress; + +#[derive(Debug, Clone, Serialize, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] -pub(crate) struct NodeHealProgress { - pub objects_scanned: u64, - pub objects_healed: u64, - pub objects_failed: u64, - pub bytes_processed: u64, +struct NodeHealProgressV1 { + objects_scanned: u64, + objects_healed: u64, + objects_failed: u64, + bytes_processed: u64, +} + +impl From<&NodeHealProgress> for NodeHealProgressV1 { + fn from(progress: &NodeHealProgress) -> Self { + Self { + objects_scanned: progress.objects_scanned, + objects_healed: progress.objects_healed, + objects_failed: progress.objects_failed, + bytes_processed: progress.bytes_processed, + } + } +} + +impl From for NodeHealProgress { + fn from(progress: NodeHealProgressV1) -> Self { + Self { + objects_scanned: progress.objects_scanned, + objects_healed: progress.objects_healed, + objects_failed: progress.objects_failed, + bytes_processed: progress.bytes_processed, + ..Default::default() + } + } } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -220,6 +246,48 @@ pub(crate) struct NodeHealStatusSnapshot { pub progress: Option, } +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(rename_all = "camelCase", deny_unknown_fields)] +struct NodeHealStatusSnapshotV1 { + version: u8, + services_enabled: bool, + initialized: bool, + info: NodeHealInfo, + operations: HealOperationsSnapshot, + progress: Option, +} + +impl From<&NodeHealStatusSnapshot> for NodeHealStatusSnapshotV1 { + fn from(snapshot: &NodeHealStatusSnapshot) -> Self { + Self { + version: NODE_HEAL_STATUS_PREVIOUS_VERSION, + services_enabled: snapshot.services_enabled, + initialized: snapshot.initialized, + info: snapshot.info.clone(), + operations: snapshot.operations, + progress: snapshot.progress.as_ref().map(NodeHealProgressV1::from), + } + } +} + +impl From for NodeHealStatusSnapshot { + fn from(snapshot: NodeHealStatusSnapshotV1) -> Self { + Self { + version: snapshot.version, + services_enabled: snapshot.services_enabled, + initialized: snapshot.initialized, + info: snapshot.info, + operations: snapshot.operations, + progress: snapshot.progress.map(NodeHealProgress::from), + } + } +} + +#[derive(Deserialize)] +struct NodeHealStatusVersion { + version: u8, +} + impl NodeHealStatusSnapshot { #[cfg(test)] pub(crate) fn for_test( @@ -249,14 +317,7 @@ impl NodeHealStatusSnapshot { } pub(crate) async fn capture_node_heal_status(info: BackgroundHealInfo) -> NodeHealStatusSnapshot { - let progress = rustfs_heal::current_heal_progress_snapshot() - .await - .map(|progress| NodeHealProgress { - objects_scanned: progress.objects_scanned, - objects_healed: progress.objects_healed, - objects_failed: progress.objects_failed, - bytes_processed: progress.bytes_processed, - }); + let progress = rustfs_heal::current_heal_progress_snapshot().await; NodeHealStatusSnapshot { version: NODE_HEAL_STATUS_VERSION, @@ -268,22 +329,43 @@ pub(crate) async fn capture_node_heal_status(info: BackgroundHealInfo) -> NodeHe } } -pub(crate) fn encode_node_heal_status(snapshot: &NodeHealStatusSnapshot) -> Result, String> { - encode_msgpack_map(snapshot).map_err(|err| format!("failed to encode node heal status: {err}")) +pub(crate) fn encode_node_heal_status(snapshot: &NodeHealStatusSnapshot, protocol_version: u32) -> Result, String> { + let encoded = if protocol_version < rustfs_protos::BACKGROUND_HEAL_STATUS_PROTOCOL_VERSION { + encode_msgpack_map(&NodeHealStatusSnapshotV1::from(snapshot)) + } else { + let mut snapshot = snapshot.clone(); + snapshot.version = NODE_HEAL_STATUS_VERSION; + encode_msgpack_map(&snapshot) + }; + encoded.map_err(|err| format!("failed to encode node heal status: {err}")) } pub(crate) fn decode_node_heal_status(data: &[u8]) -> Result { if data.len() > NODE_HEAL_STATUS_MAX_SIZE { return Err("node heal status exceeds size limit".to_string()); } - let mut deserializer = Deserializer::new(Cursor::new(data)); - let snapshot = NodeHealStatusSnapshot::deserialize(&mut deserializer) - .map_err(|err| format!("failed to decode node heal status: {err}"))?; + let decode_version = || { + let mut deserializer = Deserializer::new(Cursor::new(data)); + NodeHealStatusVersion::deserialize(&mut deserializer) + .map(|version| (version, deserializer)) + .map_err(|err| format!("failed to decode node heal status: {err}")) + }; + let (version, deserializer) = decode_version()?; if usize::try_from(deserializer.get_ref().position()).ok() != Some(data.len()) { return Err("node heal status contains trailing data".to_string()); } - if snapshot.version != NODE_HEAL_STATUS_VERSION { - return Err(format!("unsupported node heal status version: {}", snapshot.version)); + + let mut deserializer = Deserializer::new(Cursor::new(data)); + let snapshot = match version.version { + NODE_HEAL_STATUS_PREVIOUS_VERSION => { + NodeHealStatusSnapshotV1::deserialize(&mut deserializer).map(NodeHealStatusSnapshot::from) + } + NODE_HEAL_STATUS_VERSION => NodeHealStatusSnapshot::deserialize(&mut deserializer), + version => return Err(format!("unsupported node heal status version: {version}")), + } + .map_err(|err| format!("failed to decode node heal status: {err}"))?; + if usize::try_from(deserializer.get_ref().position()).ok() != Some(data.len()) { + return Err("node heal status contains trailing data".to_string()); } Ok(snapshot) } @@ -387,9 +469,10 @@ pub(crate) fn decode_node_replacement_recovery_status(data: &[u8]) -> Result