refactor: migrate consumers off rustfs-common heal/scanner shims (#6623)

* refactor(ecstore): import heal/scanner contracts crates directly (backlog#1843)

* refactor(heal): import heal/scanner contracts crates directly (backlog#1843)

* refactor(lifecycle): import heal/scanner contracts crates directly (backlog#1843)

* refactor(obs): import heal/scanner contracts crates directly (backlog#1843)

* refactor(protos): import heal/scanner contracts crates directly (backlog#1843)

* refactor(scanner): import heal/scanner contracts crates directly (backlog#1843)

* refactor(rustfs): import heal/scanner contracts crates directly (backlog#1843)

crates/heal/src/heal/channel.rs

@@ -19,7 +19,7 @@ use crate::heal::{
     utils,
 };
 use crate::{Error, Result};
-use rustfs_common::heal_channel::{
+use rustfs_heal_contracts::heal_channel::{
     HealAdmissionReceipt, HealAdmissionResult, HealChannelCommand, HealChannelPriority, HealChannelReceiver, HealChannelRequest,
     HealChannelResponse, HealReceiptCommand, HealReceiptReceiver, HealRequestSource, HealScanMode, publish_heal_response,
 };
@@ -763,7 +763,7 @@ mod tests {
     use super::*;
     use crate::heal::manager::HealConfig;
     use crate::heal::storage::{HealObjectInfo, HealStorageAPI};
-    use rustfs_common::heal_channel::{
+    use rustfs_heal_contracts::heal_channel::{
         HealAdmissionDropReason, HealAdmissionResult, HealChannelPriority, HealChannelRequest, HealRequestSource, HealScanMode,
     };
     use std::sync::Arc;
@@ -793,14 +793,14 @@ mod tests {
             _bucket: &str,
             _object: &str,
             _version_id: Option<&str>,
-            _opts: &rustfs_common::heal_channel::HealOpts,
+            _opts: &rustfs_heal_contracts::heal_channel::HealOpts,
         ) -> crate::Result<(rustfs_madmin::heal_commands::HealResultItem, Option<crate::Error>)> {
             Ok((rustfs_madmin::heal_commands::HealResultItem::default(), None))
         }
         async fn heal_bucket(
             &self,
             _bucket: &str,
-            _opts: &rustfs_common::heal_channel::HealOpts,
+            _opts: &rustfs_heal_contracts::heal_channel::HealOpts,
         ) -> crate::Result<rustfs_madmin::heal_commands::HealResultItem> {
             Ok(rustfs_madmin::heal_commands::HealResultItem::default())
         }
@@ -1368,7 +1368,7 @@ mod tests {
             source: HealRequestSource::Admin,
             ..Default::default()
         };
-        let mut responses = rustfs_common::heal_channel::subscribe_heal_responses();
+        let mut responses = rustfs_heal_contracts::heal_channel::subscribe_heal_responses();
 
         let (tx, rx) = oneshot::channel();
         processor

crates/heal/src/heal/erasure_healer.rs

@@ -24,7 +24,7 @@ use crate::heal::{
 use crate::{Error, Result};
 use futures::{StreamExt, stream::FuturesUnordered};
 use metrics::{counter, gauge};
-use rustfs_common::heal_channel::{HealOpts, HealRequestSource, HealScanMode};
+use rustfs_heal_contracts::heal_channel::{HealOpts, HealRequestSource, HealScanMode};
 use rustfs_madmin::heal_commands::HealResultItem;
 use std::sync::{
     Arc,
@@ -1346,7 +1346,7 @@ impl ErasureSetHealer {
 #[cfg(test)]
 mod tests {
     use super::{ErasureSetHealer, PageConcurrencyGuard};
-    use rustfs_common::heal_channel::{HealRequestSource, HealScanMode};
+    use rustfs_heal_contracts::heal_channel::{HealRequestSource, HealScanMode};
     use std::sync::{
         Arc,
         atomic::{AtomicUsize, Ordering},
@@ -1523,7 +1523,7 @@ mod resume_loop_tests {
         BUCKET_META_PREFIX, DiskOption, DiskStore, EcstoreError, Endpoint, HealDiskExt as _, RUSTFS_META_BUCKET, new_disk,
     };
     use crate::{Error, Result};
-    use rustfs_common::heal_channel::{HealOpts, HealRequestSource};
+    use rustfs_heal_contracts::heal_channel::{HealOpts, HealRequestSource};
     use rustfs_madmin::heal_commands::{HealDriveInfo, HealResultItem, Infos};
     use std::collections::{HashMap, HashSet, VecDeque};
     use std::sync::atomic::{AtomicBool, Ordering};

crates/heal/src/heal/manager.rs

@@ -20,8 +20,10 @@ use crate::heal::{
 };
 use crate::{Error, Result};
 use metrics::{counter, gauge};
-use rustfs_common::heal_channel::{HealAdmissionDropReason, HealAdmissionReceipt, HealAdmissionResult, HealRequestSource};
 use rustfs_concurrency::{AdmissionState, WorkloadAdmissionSnapshotProvider, WorkloadClass};
+use rustfs_heal_contracts::heal_channel::{
+    HealAdmissionDropReason, HealAdmissionReceipt, HealAdmissionResult, HealRequestSource,
+};
 use rustfs_madmin::heal_commands::HealResultItem;
 #[cfg(test)]
 use std::sync::LazyLock;

crates/heal/src/heal/manager/tests.rs

@@ -17,8 +17,8 @@ use crate::heal::EcstoreError;
 use crate::heal::resume::{CheckpointManager, ReplacementTargetIdentity};
 use crate::heal::storage::{HealObjectInfo, HealStorageAPI};
 use crate::heal::task::{BatchHealFailure, HealOptions, HealPriority, HealRequest, HealTask, HealType};
-use rustfs_common::heal_channel::{HealOpts, HealRequestSource};
 use rustfs_concurrency::{WorkloadAdmissionRegistrySnapshot, WorkloadAdmissionSnapshot};
+use rustfs_heal_contracts::heal_channel::{HealOpts, HealRequestSource};
 use rustfs_madmin::heal_commands::HealResultItem;
 use std::sync::Mutex as StdMutex;
 use tempfile::TempDir;

crates/heal/src/heal/mrf_queue.rs

@@ -35,8 +35,8 @@
 use super::{DiskStore, HealDiskExt as _, local_disk_map_read};
 use crate::heal::manager::{HealManager, MrfRepairNoticeTarget};
 use metrics::{counter, gauge};
-use rustfs_common::heal_channel::{HealAdmissionDropReason, HealAdmissionResult};
 use rustfs_common::mrf_channel::{MRF_MAX_ATTEMPTS, MrfIntent};
+use rustfs_heal_contracts::heal_channel::{HealAdmissionDropReason, HealAdmissionResult};
 use std::collections::{HashSet, VecDeque};
 use std::sync::Arc;
 use std::time::Duration;
@@ -483,7 +483,7 @@ pub(crate) fn build_heal_request(intent: &MrfIntent) -> HealRequest {
         options.set_index = usize::try_from(scope.set_index).ok();
     }
     let mut request = HealRequest::new(heal_type, options, priority);
-    request.source = rustfs_common::heal_channel::HealRequestSource::Mrf;
+    request.source = rustfs_heal_contracts::heal_channel::HealRequestSource::Mrf;
     request
 }
 

crates/heal/src/heal/storage.rs

@@ -16,7 +16,7 @@ use crate::{Error, Result};
 use async_trait::async_trait;
 use base64::Engine as _;
 use base64::engine::general_purpose::URL_SAFE_NO_PAD;
-use rustfs_common::heal_channel::{HealOpts, HealScanMode};
+use rustfs_heal_contracts::heal_channel::{HealOpts, HealScanMode};
 use rustfs_madmin::heal_commands::HealResultItem;
 use serde::{Deserialize, Serialize};
 use std::sync::Arc;

crates/heal/src/heal/task.rs

@@ -23,8 +23,8 @@ use crate::heal::{
 };
 use crate::{Error, Result};
 use metrics::{counter, histogram};
-use rustfs_common::heal_channel::{HealOpts, HealRequestSource, HealScanMode};
 use rustfs_common::trace_bus::{TraceEvent, TraceFunc, TraceKind, trace_emit};
+use rustfs_heal_contracts::heal_channel::{HealOpts, HealRequestSource, HealScanMode};
 use rustfs_madmin::heal_commands::HealResultItem;
 use rustfs_utils::path::SLASH_SEPARATOR;
 use serde::{Deserialize, Serialize};

crates/heal/src/lib.rs

@@ -176,7 +176,7 @@ pub async fn init_heal_manager_with_workload_provider(
         let channel_receiver = if force_channel_failure {
             Err("forced heal channel initialization failure")
         } else {
-            rustfs_common::heal_channel::init_heal_channels()
+            rustfs_heal_contracts::heal_channel::init_heal_channels()
         };
         let (receiver, receipt_receiver) = match channel_receiver {
             Ok(receivers) => receivers,
@@ -358,7 +358,7 @@ mod tests {
         heal::storage::HealStorageAPI, init_heal_manager, run_owned_initialization,
     };
     use crate::heal::storage_api::status::BucketInfo;
-    use rustfs_common::heal_channel::HealOpts;
+    use rustfs_heal_contracts::heal_channel::HealOpts;
     use rustfs_madmin::heal_commands::HealResultItem;
     use std::sync::Arc;
     use std::sync::atomic::{AtomicBool, Ordering};