fix(ecstore): fence rebalance and decommission activation (#6400)

* fix(ecstore): fence rebalance and decommission activation

* fix(ecstore): fence lost activation locks

* fix(ecstore): bind rebalance workers to activation id

* fix(ecstore): close rebalance activation races

* test(ecstore): exercise lost rebalance commit fence

* fix(ecstore): repair rebalance fence test wiring

* test(ecstore): reuse rebalance metadata fixture

* fix(ecstore): satisfy rebalance activation clippy checks

* fix(ecstore): fence stale rebalance workers

* fix(ecstore): commit rebalance activation after persistence

* fix(ecstore): fence rebalance commits and unblock stop

* test(ecstore): exercise real rebalance fences

* fix(rebalance): cancel admin stop before activation wait

* fix(ecstore): fence multipart staging on rebalance lock loss

* fix(ecstore): adopt activations after durable commit

* fix(rebalance): preserve committed activation recovery

* fix(rebalance): make prepared stop terminal-safe

* fix(ecstore): repair rebalance test imports

* fix(ecstore): repair rebalance entry runtime failures

* test(ecstore): fix activation fence synchronization

* test(ecstore): scope rebalance disk trait import

* test(ecstore): observe decommission lock attempt

* fix(ecstore): align activation fence test imports

* fix(ecstore): remove duplicate activation test import

* fix(ecstore): resolve CI clippy failures

* fix: satisfy activation merge lint gates

---------

Co-authored-by: houseme <housemecn@gmail.com>

crates/ecstore/src/services/rebalance/mod.rs

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#[cfg(test)]
+use crate::disk::DiskAPI;
 use crate::error::{Error, Result};
 use crate::object_api::{GetObjectReader, ObjectInfo, ObjectOptions, PutObjReader};
 use tokio::time::Duration;
@@ -45,6 +47,8 @@ mod runtime;
 mod types;
 mod worker;
 
+#[cfg(feature = "test-util")]
+pub use entry::test_util::PausedRebalanceEntryTestFixture;
 pub(crate) use meta::is_rebalance_conflicting_with_decommission;
 pub use meta::{decode_rebalance_stop_propagation_record, encode_rebalance_stop_propagation_record};
 pub use types::{
@@ -53,5 +57,130 @@ pub use types::{
 };
 use types::{RebalanceBucketConfigs, RebalanceBucketOutcome, RebalanceEntryOutcome};
 
+#[cfg(any(test, feature = "test-util"))]
+pub async fn test_store_with_persisted_rebalance_meta(
+    meta: RebalanceMeta,
+) -> (Vec<tempfile::TempDir>, std::sync::Arc<crate::store::ECStore>) {
+    let ctx = std::sync::Arc::new(crate::runtime::instance::InstanceContext::new());
+    let (temp_dirs, pool) = crate::core::sets::make_local_two_set_sets_with_ctx(ctx.clone()).await;
+    meta.save(pool.clone())
+        .await
+        .expect("rebalance test metadata should be persisted");
+    let endpoint_pools: crate::layout::endpoints::EndpointServerPools = vec![pool.endpoints.clone()].into();
+    let store = std::sync::Arc::new(crate::store::ECStore {
+        id: uuid::Uuid::new_v4(),
+        disk_map: std::collections::HashMap::new(),
+        pools: vec![pool],
+        peer_sys: crate::cluster::rpc::S3PeerSys::new_with_instance_ctx(&endpoint_pools, ctx.clone()),
+        pool_meta: tokio::sync::RwLock::new(crate::core::pools::PoolMeta::default()),
+        rebalance_meta: tokio::sync::RwLock::new(Some(meta)),
+        decommission_cancelers: tokio::sync::RwLock::new(vec![None]),
+        start_gate: tokio::sync::Mutex::new(()),
+        pool_meta_save_gate: tokio::sync::Mutex::new(()),
+        ctx,
+        bucket_fence_registry: std::sync::Arc::default(),
+    });
+    (temp_dirs, store)
+}
+
+#[cfg(test)]
+pub(crate) async fn test_two_pool_stores(
+    rebalance_meta: Option<RebalanceMeta>,
+) -> (
+    Vec<tempfile::TempDir>,
+    std::sync::Arc<crate::store::ECStore>,
+    std::sync::Arc<crate::store::ECStore>,
+) {
+    test_two_pool_stores_with_contexts(rebalance_meta, false).await
+}
+
+#[cfg(test)]
+pub(crate) async fn test_two_pool_stores_with_isolated_node_contexts(
+    rebalance_meta: Option<RebalanceMeta>,
+) -> (
+    Vec<tempfile::TempDir>,
+    std::sync::Arc<crate::store::ECStore>,
+    std::sync::Arc<crate::store::ECStore>,
+) {
+    test_two_pool_stores_with_contexts(rebalance_meta, true).await
+}
+
+#[cfg(test)]
+async fn test_two_pool_stores_with_contexts(
+    rebalance_meta: Option<RebalanceMeta>,
+    isolate_node_contexts: bool,
+) -> (
+    Vec<tempfile::TempDir>,
+    std::sync::Arc<crate::store::ECStore>,
+    std::sync::Arc<crate::store::ECStore>,
+) {
+    crate::services::notification_sys::install_cross_pool_fence_fleet_proof_for_test();
+    use crate::core::pools::PoolMeta;
+    use crate::layout::endpoints::{EndpointServerPools, SetupType};
+
+    let ctx = std::sync::Arc::new(crate::runtime::instance::InstanceContext::new());
+    ctx.update_erasure_type(SetupType::DistErasure).await;
+    let (mut temp_dirs, first_pool) =
+        crate::core::sets::make_local_two_set_sets_for_pool_with_ctx(std::sync::Arc::clone(&ctx), 0).await;
+    let (second_temp_dirs, second_pool) =
+        crate::core::sets::make_local_two_set_sets_for_pool_with_ctx(std::sync::Arc::clone(&ctx), 1).await;
+    temp_dirs.extend(second_temp_dirs);
+    let pools = vec![first_pool, second_pool];
+    {
+        let local_disk_map = ctx.local_disk_map();
+        let mut local_disk_map = local_disk_map.write().await;
+        for pool in &pools {
+            for set in &pool.disk_set {
+                for disk in set.disks.read().await.iter().flatten() {
+                    local_disk_map.insert(disk.endpoint().to_string(), Some(disk.clone()));
+                }
+            }
+        }
+    }
+    let pool_meta = PoolMeta::new(&pools, &PoolMeta::default());
+    pool_meta
+        .save(pools.clone())
+        .await
+        .expect("baseline pool metadata should be persisted");
+    if let Some(meta) = rebalance_meta.as_ref() {
+        meta.save(pools[0].clone())
+            .await
+            .expect("active rebalance metadata should be persisted");
+    }
+    let endpoint_pools: EndpointServerPools = pools.iter().map(|pool| pool.endpoints.clone()).collect::<Vec<_>>().into();
+    ctx.set_endpoints(endpoint_pools.clone());
+    let other_ctx = if isolate_node_contexts {
+        let other_ctx = std::sync::Arc::new(crate::runtime::instance::InstanceContext::new());
+        other_ctx.update_erasure_type(SetupType::DistErasure).await;
+        *other_ctx.local_disk_map().write().await = ctx.local_disk_map().read().await.clone();
+        other_ctx.set_endpoints(endpoint_pools.clone());
+        other_ctx
+    } else {
+        std::sync::Arc::clone(&ctx)
+    };
+    let make_store = |store_ctx: std::sync::Arc<crate::runtime::instance::InstanceContext>| {
+        std::sync::Arc::new(crate::store::ECStore {
+            id: uuid::Uuid::new_v4(),
+            disk_map: std::collections::HashMap::new(),
+            pools: pools.clone(),
+            peer_sys: crate::cluster::rpc::S3PeerSys::new_with_instance_ctx(&endpoint_pools, std::sync::Arc::clone(&store_ctx)),
+            pool_meta: tokio::sync::RwLock::new(pool_meta.clone()),
+            rebalance_meta: tokio::sync::RwLock::new(rebalance_meta.clone()),
+            decommission_cancelers: tokio::sync::RwLock::new(vec![None, None]),
+            start_gate: tokio::sync::Mutex::new(()),
+            pool_meta_save_gate: tokio::sync::Mutex::new(()),
+            ctx: store_ctx,
+            bucket_fence_registry: std::sync::Arc::default(),
+        })
+    };
+    let store = make_store(ctx);
+    let other_store = make_store(other_ctx);
+    if isolate_node_contexts {
+        crate::bucket::metadata_sys::init_bucket_metadata_sys(std::sync::Arc::clone(&store), Vec::new()).await;
+        crate::bucket::metadata_sys::init_bucket_metadata_sys(std::sync::Arc::clone(&other_store), Vec::new()).await;
+    }
+    (temp_dirs, store, other_store)
+}
+
 #[cfg(test)]
 mod rebalance_unit_tests;