fix(test): preserve inclusive ABBA thresholds

Use decimal boundary comparisons for ABBA ratio checks and cover exact documented p99, throughput, and P1 limits.

Co-Authored-By: heihutu <heihutu@gmail.com>

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>

.config/make/tests.mak

@@ -31,6 +31,7 @@ script-tests: ## Run shell script tests
 	./scripts/test_object_batch_bench_enhanced.sh
 	./scripts/test_hotpath_warp_ab_gate.sh
 	./scripts/test_hotpath_warp_abba.sh
+	./scripts/test_scanner_validation_harness.sh
 	./scripts/test_exact_1mib_handoff_abba.sh
 	./scripts/test_pinned_paired_abba_bench.sh
 	./scripts/test_manual_transition_runbooks.sh

.config/scanner-heal-required-tests.json

@@ -0,0 +1,40 @@
+{
+  "schema": 1,
+  "cases": {
+    "background-target-restart": {
+      "gate": "G14",
+      "task": "W21",
+      "lane": "e2e-nightly",
+      "suite": "e2e_test",
+      "name": "heal_erasure_disk_rebuild_test::tests::test_cluster_root_heal_recovers_remote_shards_after_background_target_restart",
+      "oracle": "background-target-restart.json",
+      "min_objects": 9,
+      "max_objects": 65,
+      "topology": {"nodes": 4, "drives_per_node": 1},
+      "scope": "Target process restart, exact unversioned S3 bodies and replacement-disk shards; not power loss or EC8+4."
+    }
+  },
+  "release_pending": {
+    "G01": "W02/W04 complete root and quota authority coverage",
+    "G02": "W03 bounded checkpoint progress and independent version inventory",
+    "G03": "W17/W18 exact scoped ACK with durable publication and mixed peers",
+    "G04": "W03/W15/W16 crash at every cache/root/floor/intent boundary",
+    "G05": "W06/W07 per-object outcomes and bounded terminal retention",
+    "G06": "W06/W08/W23 concurrent status, legacy clients and truncation",
+    "G07": "W12/W13/W14 durable MRF responsibility at every commit boundary",
+    "G08": "W12/W13/W14 MRF capacity, disk-full and replica-loss matrix",
+    "G09": "W13/W18/W23 actual mixed-version reader/writer and rollback payloads",
+    "G10": "W05/W09/W10/W11 bounded scheduling and pressure recovery",
+    "G11": "W04/W19/W24 maintenance and complete producer coverage",
+    "G12": "W02/W15/W16 both quota paths during reset and settlement",
+    "G13": "W07/W14 quorum-minus-one, unknown disks, remount, Object Lock, dry-run, grace and commit tail",
+    "G14": "W20/W21 same-window field evidence; 3x4 EC8+4 and multi-set/pool coverage",
+    "P1": "W20 measured cold-walk share and foreground latency/throughput",
+    "P2": "W20/W24 measured post-stop convergence and cold segment reuse",
+    "P3": "W20 measured two-hour pressure/heal capacity and recovery window",
+    "P4": "W20 measured MRF scale and replay cost with retained responsibility",
+    "R-E": "W03/W05 fixed-budget real process restart through enumeration and classification",
+    "R-D": "W07/W14 manager-to-event-to-ledger exact disposition, including grace",
+    "R-L": "W13/W14 legacy source conflicts, migration gaps and crash-safe source retirement"
+  }
+}

.github/workflows/e2e-upgrade.yml

@@ -19,9 +19,7 @@ on:
     paths:
       - ".github/workflows/e2e-upgrade.yml"
       - "crates/e2e_test/src/common.rs"
-      - "crates/e2e_test/src/fake_s3_target/**"
       - "crates/e2e_test/src/lib.rs"
-      - "crates/e2e_test/src/replication_extension_test.rs"
       - "crates/e2e_test/src/upgrade_compatibility_test.rs"
       - "crates/ecstore/**"
       - "crates/filemeta/**"
@@ -46,9 +44,9 @@ concurrency:
 env:
   CARGO_TERM_COLOR: always
   RUST_BACKTRACE: 1
-  UPGRADE_SOURCE_VERSION: 1.0.0-rc.5
-  UPGRADE_SOURCE_ASSET: rustfs-linux-x86_64-gnu-v1.0.0-rc.5.zip
-  UPGRADE_SOURCE_SHA256: 3ee8df71e8edcfada533be452c4135868f697bc515460ae97b027313eade7a3d
+  UPGRADE_SOURCE_VERSION: 1.0.0-rc.2
+  UPGRADE_SOURCE_ASSET: rustfs-linux-x86_64-gnu-v1.0.0-rc.2.zip
+  UPGRADE_SOURCE_SHA256: 7c789386bf85278f865b8e0d359bf4edb84d5aa408cc3fa54a18c25ca74cd6e7
 
 jobs:
   upgrade:
@@ -57,31 +55,14 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          # The two `_from_rc2_` tests keep their names: they assert
-          # release-independent object contracts and pass unchanged against the
-          # newer pinned source, so renaming them would only churn history and
-          # the CI required-check names. UPGRADE_SOURCE_VERSION above is the
-          # single source of truth for which release they actually run against.
-          - name: Direct upgrade from the previous release
+          - name: Direct upgrade from rc.2
             cache_key: e2e-direct-upgrade
             test: direct_upgrade_from_rc2_preserves_object_contracts
             artifact: direct-upgrade
-          - name: Mixed-version rolling upgrade from the previous release
+          - name: Mixed-version rolling upgrade from rc.2
             cache_key: e2e-mixed-version-upgrade
             test: rolling_upgrade_from_rc2_preserves_mixed_version_contracts
             artifact: mixed-version-upgrade
-          - name: Bucket configuration survives the upgrade
-            cache_key: e2e-bucket-config-upgrade
-            test: direct_upgrade_from_previous_release_preserves_bucket_configuration
-            artifact: bucket-config-upgrade
-          - name: Rollback reads current bucket metadata
-            cache_key: e2e-bucket-config-rollback
-            test: rollback_to_previous_release_reads_current_bucket_metadata
-            artifact: bucket-config-rollback
-          - name: ODM configuration recovery after rc.5 rollback
-            cache_key: e2e-odm-config-rollback
-            test: rc5_rollback_requires_restoring_odm_configuration
-            artifact: odm-config-rollback
     runs-on: ubuntu-latest
     timeout-minutes: 60
     env:

CHANGELOG.md

@@ -18,10 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Read paths: an object at or below `policy.inline_max_bytes` (16 MiB by default) is teed to the client and to the local store in a single source read; a larger object or a Range read streams through and a background pull stores the whole object. A HEAD miss is proxied to the source and stores nothing (`policy.head = local_only` disables it). Every source-backed response carries `x-rustfs-on-demand-migration: source`
   - Protections: a per-source circuit breaker, a per-key negative cache, singleflight per key, a concurrency limit and a bounded pull queue shared by the inline and background paths, an optional bandwidth limit, an anti-loop request marker, and the shared outbound-endpoint (SSRF) policy
   - Metrics under `rustfs_on_demand_migration_*` (`requests_total`, `pulled_bytes_total`, `pulled_objects_total`, `pull_failures_total`, `inflight_pulls`, `queue_depth`, `source_latency_seconds_*`, `breaker_state`), mirrored per node by the admin status route
-  - Listings: `ListObjects` v1 remains local with ordinary key markers. `ListObjectsV2` can merge source objects when `policy.list_through = true`; this is off by default
-  - Upgrade and rollback: finish upgrading every node before enabling ODM. An rc.5 node that writes bucket configuration drops the ODM fields from metadata; neither a later restart nor moving the service out of ECStore recovers them. Before rollback, disable ODM and securely retain the original full configuration and credentials. After every node returns to a compatible version, restore and validate that configuration. Redacted exports cannot replace the credential backup; source-only objects are unavailable through RustFS while ODM is disabled. See the upgrade and rollback section of `docs/operations/on-demand-migration.md`
-  - Optional Google dependencies: default and `full` server builds retain native GCS support. `cargo build -p rustfs --no-default-features --features ftps,webdav` excludes Google SDKs while preserving configuration decoding and redaction; native GCS ODM and tier operations require the `gcs` feature. Do not use that build with existing GCS-tiered data
-  - Limitations: PUT and DELETE never reach the source; a source object updated after it was pulled is not re-fetched; SSE-C source objects are unsupported and answer 424; `Last-Modified` on a pulled object is the local write time, with the source timestamp kept in metadata
+  - Limitations: listings show only local objects (the source is not merged into `ListObjectsV2`); PUT and DELETE never reach the source; a source object updated after it was pulled is not re-fetched; SSE-C source objects are unsupported and answer 424; `Last-Modified` on a pulled object is the local write time, with the source timestamp kept in metadata
 - **NATS JetStream Publish Path**: Opt-in at-least-once delivery for the NATS notify and audit targets. A NATS Core publish flushes to the connection without awaiting a broker acknowledgement, so an event can be lost across a broker restart or a reconnect after the send queue has already cleared it. A queued event now clears only after the JetStream `PublishAck`, so bucket notifications survive those interruptions. Off by default and byte-identical to the NATS Core path when disabled.
   - Three configuration keys per target: `JETSTREAM_ENABLE`, `JETSTREAM_STREAM_NAME`, and `JETSTREAM_ACK_TIMEOUT_SECS`, under the `RUSTFS_NOTIFY_NATS_` and `RUSTFS_AUDIT_NATS_` prefixes
   - Durable store-and-forward with a stable dedup id sent as the `Nats-Msg-Id` header, so a replay after a crash is collapsed by the server duplicate window

Cargo.lock

@@ -9493,8 +9493,6 @@ dependencies = [
  "atomic_enum",
  "aws-config",
  "aws-sdk-s3",
- "aws-smithy-runtime-api",
- "aws-smithy-types",
  "axum",
  "base64-simd",
  "bytes",
@@ -9503,13 +9501,11 @@ dependencies = [
  "clap",
  "const-str",
  "datafusion",
- "faster-hex",
  "flatbuffers",
  "flate2",
  "futures",
  "futures-lite",
  "futures-util",
- "google-cloud-auth",
  "hashbrown 0.17.1",
  "hex-simd",
  "hmac 0.13.0",
@@ -9528,7 +9524,6 @@ dependencies = [
  "metrics",
  "metrics-util",
  "mime_guess",
- "moka",
  "opentelemetry",
  "opentelemetry_sdk",
  "p256 0.14.0",
@@ -9621,7 +9616,6 @@ dependencies = [
  "urlencoding",
  "uuid",
  "x509-parser",
- "xxhash-rust",
  "zeroize",
  "zip",
  "zstd 0.14.0",
@@ -9798,6 +9792,7 @@ dependencies = [
  "path-absolutize",
  "pin-project-lite",
  "proptest",
+ "quick-xml",
  "rand 0.10.2",
  "ratelimit",
  "rcgen",

crates/e2e_test/build.rs

@@ -0,0 +1,74 @@
+// Copyright 2024 RustFS Team
+// Licensed under the Apache License, Version 2.0.
+
+use std::path::Path;
+use std::process::Command;
+
+fn git(root: &Path, args: &[&str]) -> Option<String> {
+    let output = Command::new("git").args(args).current_dir(root).output().ok()?;
+    output
+        .status
+        .success()
+        .then(|| String::from_utf8_lossy(&output.stdout).trim().to_owned())
+}
+
+fn emit(name: &str, value: &str) {
+    let value = if value.contains(['\n', '\r']) { "unknown" } else { value };
+    println!("cargo:rustc-env=RUSTFS_E2E_BUILD_{name}={value}");
+}
+
+fn main() {
+    let manifest = std::env::var_os("CARGO_MANIFEST_DIR").unwrap_or_default();
+    let root = Path::new(&manifest).join("../..");
+    // Cover dependency/common sources as well as this crate. HEAD/ref/index
+    // changes must refresh identity even when no Rust source mtime changes.
+    for path in [
+        "crates",
+        "rustfs",
+        "Cargo.toml",
+        "Cargo.lock",
+        "rust-toolchain.toml",
+        ".cargo",
+        ".config",
+    ] {
+        println!("cargo:rerun-if-changed={}", root.join(path).display());
+    }
+    let mut git_paths = vec!["HEAD".to_owned(), "index".to_owned(), "packed-refs".to_owned()];
+    if let Some(reference) = git(&root, &["symbolic-ref", "-q", "HEAD"]) {
+        git_paths.push(reference);
+    }
+    for path in git_paths {
+        if let Some(path) = git(&root, &["rev-parse", "--git-path", &path]) {
+            let path = Path::new(&path);
+            let path = if path.is_absolute() {
+                path.to_owned()
+            } else {
+                root.join(path)
+            };
+            if path.exists() {
+                println!("cargo:rerun-if-changed={}", path.display());
+            }
+        }
+    }
+    let revision = git(&root, &["rev-parse", "HEAD"]).unwrap_or_else(|| "unknown".to_owned());
+    let dirty = git(&root, &["status", "--porcelain", "--untracked-files=normal"]).is_none_or(|status| !status.is_empty());
+    let lock = git(&root, &["hash-object", "Cargo.lock"]).unwrap_or_else(|| "unknown".to_owned());
+    let mut features = std::env::vars()
+        .filter_map(|(key, _)| {
+            key.strip_prefix("CARGO_FEATURE_")
+                .map(|name| name.to_ascii_lowercase().replace('_', "-"))
+        })
+        .collect::<Vec<_>>();
+    features.sort();
+    emit("COMMIT", &revision);
+    emit("DIRTY", if dirty { "true" } else { "false" });
+    emit("LOCK", &lock);
+    emit("FEATURES", &features.join(","));
+    for name in ["TARGET", "PROFILE"] {
+        emit(name, &std::env::var(name).unwrap_or_else(|_| "unknown".to_owned()));
+    }
+    println!("cargo:rerun-if-env-changed=CARGO_ENCODED_RUSTFLAGS");
+    let flags = std::env::var("CARGO_ENCODED_RUSTFLAGS").unwrap_or_default();
+    let flags: String = flags.as_bytes().iter().map(|byte| format!("{byte:02x}")).collect();
+    emit("RUSTFLAGS_HEX", &flags);
+}

crates/e2e_test/src/chaos.rs

@@ -55,18 +55,20 @@ type ChaosResult<T> = Result<T, Box<dyn Error + Send + Sync>>;
 /// A successful S3 GET only proves that a quorum can serve an object. Replacement
 /// tests need this lower-level record to prove that the rebuilt target holds the
 /// `xl.meta` selected for a specific version and every `part.N` it declares.
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 pub(crate) struct VersionShardCensus {
     pub version_id: Option<String>,
     pub has_xl_meta: bool,
     pub data_dir: Option<String>,
     pub erasure_index: Option<usize>,
+    pub data_blocks: Option<usize>,
+    pub parity_blocks: Option<usize>,
     pub expected_part_numbers: BTreeSet<usize>,
     pub present_part_fingerprints: BTreeMap<usize, PartShardFingerprint>,
     pub inline_data_fingerprint: Option<PartShardFingerprint>,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize)]
 pub(crate) struct PartShardFingerprint {
     pub size: u64,
     pub sha256: String,
@@ -88,13 +90,15 @@ impl VersionShardCensus {
             && manifest.is_complete()
             && self.data_dir == manifest.data_dir
             && self.erasure_index == manifest.erasure_index
+            && self.data_blocks == manifest.data_blocks
+            && self.parity_blocks == manifest.parity_blocks
             && self.expected_part_numbers == manifest.expected_part_numbers
             && self.present_part_fingerprints == manifest.present_part_fingerprints
             && self.inline_data_fingerprint == manifest.inline_data_fingerprint
     }
 }
 
-fn sha256_hex(data: &[u8]) -> String {
+pub(crate) fn sha256_hex(data: &[u8]) -> String {
     let digest = Sha256::digest(data);
     digest.iter().map(|byte| format!("{byte:02x}")).collect()
 }
@@ -313,6 +317,8 @@ pub(crate) fn census_object_version_on_disk(
             has_xl_meta: false,
             data_dir: None,
             erasure_index: None,
+            data_blocks: None,
+            parity_blocks: None,
             expected_part_numbers: BTreeSet::new(),
             present_part_fingerprints: BTreeMap::new(),
             inline_data_fingerprint: None,
@@ -360,6 +366,8 @@ pub(crate) fn census_object_version_on_disk(
         has_xl_meta: true,
         data_dir,
         erasure_index,
+        data_blocks: Some(file_info.erasure.data_blocks),
+        parity_blocks: Some(file_info.erasure.parity_blocks),
         expected_part_numbers,
         present_part_fingerprints,
         inline_data_fingerprint,
@@ -413,6 +421,8 @@ mod tests {
             has_xl_meta: true,
             data_dir: Some("data-dir".to_string()),
             erasure_index: Some(3),
+            data_blocks: Some(2),
+            parity_blocks: Some(2),
             expected_part_numbers: BTreeSet::from([1]),
             present_part_fingerprints: BTreeMap::from([(1, shard_fingerprint(b"part").unwrap())]),
             inline_data_fingerprint: None,

crates/e2e_test/src/heal_erasure_disk_rebuild_test.rs

@@ -16,15 +16,18 @@
 
 #[cfg(test)]
 mod tests {
-    use crate::chaos::{VersionShardCensus, census_object_version_on_disk, signed_admin_post};
+    use crate::chaos::{VersionShardCensus, census_object_version_on_disk, sha256_hex, signed_admin_post};
     use crate::common::{
         FAST_DATA_USAGE_SCANNER_ENV, RustFSTestClusterEnvironment, RustFSTestEnvironment, admin_request, init_logging,
+        rustfs_binary_path,
     };
     use crate::storage_api::RUSTFS_META_BUCKET;
     use aws_sdk_s3::primitives::ByteStream;
     use http::Method;
+    use sha2::{Digest, Sha256};
     use std::collections::HashSet;
     use std::error::Error;
+    use std::io::{Read, Write};
     use std::net::SocketAddr;
     use std::path::{Path, PathBuf};
     use std::process::Command;
@@ -34,6 +37,76 @@ mod tests {
 
     const POOL_METADATA_OBJECT: &str = "pool.bin";
 
+    #[derive(serde::Deserialize)]
+    struct EvidenceBuild {
+        sha256: String,
+    }
+
+    #[derive(serde::Deserialize)]
+    struct RestartEvidenceRun {
+        schema: u32,
+        run_id: String,
+        source_revision: String,
+        test_build: serde_json::Value,
+        binary: EvidenceBuild,
+        test_binary: EvidenceBuild,
+    }
+
+    fn file_sha256(path: &Path) -> Result<String, Box<dyn Error + Send + Sync>> {
+        let mut file = std::fs::File::open(path)?;
+        let mut digest = Sha256::new();
+        let mut buffer = [0_u8; 64 * 1024];
+        loop {
+            let read = file.read(&mut buffer)?;
+            if read == 0 {
+                break;
+            }
+            digest.update(&buffer[..read]);
+        }
+        Ok(digest.finalize().iter().map(|byte| format!("{byte:02x}")).collect())
+    }
+
+    fn restart_evidence_run(binary: &Path) -> Result<Option<(PathBuf, RestartEvidenceRun)>, Box<dyn Error + Send + Sync>> {
+        let Some(directory) = std::env::var_os("RUSTFS_SCANNER_HEAL_RUN_DIR") else {
+            return Ok(None);
+        };
+        let directory = PathBuf::from(directory);
+        let receipt = directory.join("run.json");
+        if receipt.metadata()?.len() > 1024 * 1024 {
+            return Err("oversized scanner/heal execution receipt".into());
+        }
+        let run: RestartEvidenceRun = serde_json::from_slice(&std::fs::read(receipt)?)?;
+        if run.schema != 1 || run.run_id.len() != 32 || run.source_revision.len() != 40 {
+            return Err("invalid scanner/heal execution identity".into());
+        }
+        let built = compiled_test_identity();
+        for key in ["source_revision", "dirty", "lock_blob", "features"] {
+            assert_eq!(built[key], run.test_build[key], "compiled test identity differs for {key}");
+        }
+        assert_eq!(file_sha256(binary)?, run.binary.sha256, "server binary must match the run receipt");
+        assert_eq!(
+            file_sha256(&std::env::current_exe()?)?,
+            run.test_binary.sha256,
+            "test executable must match the run receipt"
+        );
+        if directory.join("background-target-restart.json").exists() {
+            return Err("scanner/heal oracle already exists; create a new execution receipt".into());
+        }
+        Ok(Some((directory, run)))
+    }
+
+    fn compiled_test_identity() -> serde_json::Value {
+        serde_json::json!({
+            "source_revision": env!("RUSTFS_E2E_BUILD_COMMIT"),
+            "dirty": env!("RUSTFS_E2E_BUILD_DIRTY") != "false",
+            "lock_blob": env!("RUSTFS_E2E_BUILD_LOCK"),
+            "features": env!("RUSTFS_E2E_BUILD_FEATURES"),
+            "target": env!("RUSTFS_E2E_BUILD_TARGET"),
+            "profile": env!("RUSTFS_E2E_BUILD_PROFILE"),
+            "rustflags_hex": env!("RUSTFS_E2E_BUILD_RUSTFLAGS_HEX"),
+        })
+    }
+
     struct TcpPortBlackhole {
         port: u16,
         comment: String,
@@ -195,8 +268,9 @@ mod tests {
         clients: &[aws_sdk_s3::Client],
         bucket: &str,
         expected_keys: &HashSet<String>,
-    ) -> Result<(), Box<dyn Error + Send + Sync>> {
+    ) -> Result<Vec<Vec<String>>, Box<dyn Error + Send + Sync>> {
         const PAGE_SIZE: i32 = 10;
+        let mut node_listings = Vec::with_capacity(clients.len());
         for (node_index, client) in clients.iter().enumerate() {
             let mut listed_keys = Vec::new();
             let mut continuation_token = None;
@@ -243,8 +317,10 @@ mod tests {
                 &listed_key_set, expected_keys,
                 "node {node_index} did not expose the complete recovered namespace"
             );
+            listed_keys.sort();
+            node_listings.push(listed_keys);
         }
-        Ok(())
+        Ok(node_listings)
     }
 
     fn heal_task_status_diagnostic(body: &str) -> String {
@@ -808,6 +884,13 @@ mod tests {
     }
 
     async fn run_cluster_root_heal_interruption(scenario: InterruptionScenario) -> Result<(), Box<dyn Error + Send + Sync>> {
+        let server_binary = rustfs_binary_path();
+        let evidence_run = if scenario == InterruptionScenario::BackgroundTargetRestart {
+            restart_evidence_run(&server_binary)?
+        } else {
+            None
+        };
+        let mut evidence_objects = Vec::new();
         let (background_enabled, interruption_node, interruption_kind) = match scenario {
             InterruptionScenario::IsolatedTargetRestart => (false, 1, "target_restart"),
             InterruptionScenario::BackgroundTargetRestart => (true, 1, "background_target_restart"),
@@ -855,7 +938,7 @@ mod tests {
         for node_index in 0..cluster.nodes.len() {
             cluster.set_node_capture_log_path(node_index, format!("{log_dir}/node{node_index}.log"))?;
         }
-        cluster.start().await?;
+        cluster.start_with_binary(&server_binary).await?;
         let clients = cluster.create_all_clients()?;
 
         let bucket = "heal-restart-during-rebuild";
@@ -996,7 +1079,7 @@ mod tests {
             }
         }
 
-        cluster.start_node(1).await?;
+        cluster.start_node_from_binary(1, &server_binary).await?;
 
         let status_url = format!("{}/rustfs/admin/v3/background-heal/status", cluster.nodes[0].url);
         let recovery_deadline = Instant::now() + Duration::from_secs(60);
@@ -1274,7 +1357,7 @@ mod tests {
                     }
                 }
             }
-            cluster.start_node(interruption_node).await?;
+            cluster.start_node_from_binary(interruption_node, &server_binary).await?;
             if interruption_node == 0 {
                 let target = cluster.nodes[1]
                     .process
@@ -1373,7 +1456,7 @@ mod tests {
             .map(|manifest| manifest.key.clone())
             .collect::<HashSet<_>>();
         assert!(expected_keys.insert(outage_key.to_string()));
-        assert_all_nodes_list_exact_keys(&clients, bucket, &expected_keys).await?;
+        let node_listings = assert_all_nodes_list_exact_keys(&clients, bucket, &expected_keys).await?;
 
         let target_client = cluster.create_s3_client(1)?;
         for expected in &expected_manifests {
@@ -1381,11 +1464,31 @@ mod tests {
             let actual = response.body.collect().await?.into_bytes();
             let expected_body = deterministic_object_body(object_size_bytes, expected.payload_seed);
             assert_eq!(actual.as_ref(), expected_body.as_slice(), "object body changed for {}", expected.key);
+            if evidence_run.is_some() {
+                evidence_objects.push(serde_json::json!({
+                    "key": expected.key, "version_id": expected.shard_census.version_id,
+                    "expected_bytes": expected_body.len(), "actual_bytes": actual.len(),
+                    "expected_sha256": sha256_hex(&expected_body),
+                    "actual_sha256": sha256_hex(&actual),
+                    "expected_physical": expected.shard_census,
+                    "physical": census_object_version_on_disk(&replaced_disk, bucket, &expected.key, None)?,
+                }));
+            }
         }
         let response = target_client.get_object().bucket(bucket).key(outage_key).send().await?;
         let actual = response.body.collect().await?.into_bytes();
         let expected_outage_body = deterministic_object_body(object_size_bytes, outage_payload_seed);
         assert_eq!(actual.as_ref(), expected_outage_body.as_slice(), "object body changed for {outage_key}");
+        if evidence_run.is_some() {
+            evidence_objects.push(serde_json::json!({
+                "key": outage_key, "version_id": null,
+                "expected_bytes": expected_outage_body.len(), "actual_bytes": actual.len(),
+                "expected_sha256": sha256_hex(&expected_outage_body),
+                "actual_sha256": sha256_hex(&actual),
+                "expected_physical": null,
+                "physical": census_object_version_on_disk(&replaced_disk, bucket, outage_key, None)?,
+            }));
+        }
 
         let terminal_deadline = Instant::now() + Duration::from_secs(30);
         loop {
@@ -1432,6 +1535,31 @@ mod tests {
             return Err(format!("heal data rebuilt but task did not finish successfully: {task_status}").into());
         }
 
+        if let Some((directory, run)) = evidence_run {
+            let restarted_pid = cluster.nodes[1].process.as_ref().ok_or("restarted target is absent")?.id();
+            assert_ne!(target_pid, restarted_pid, "target must be a new process");
+            assert_eq!(file_sha256(&server_binary)?, run.binary.sha256, "server build changed during restart");
+            let evidence = serde_json::json!({
+                "schema": 1, "case": "background-target-restart", "evidence": "process-restart",
+                "run_id": run.run_id, "source_revision": run.source_revision,
+                "test_build": compiled_test_identity(),
+                "binary_sha256": run.binary.sha256, "test_binary_sha256": run.test_binary.sha256,
+                "topology": {"nodes": cluster.nodes.len(), "drives_per_node": cluster.nodes[0].data_dirs.len()},
+                "pid_before": target_pid, "pid_after": restarted_pid,
+                "objects": evidence_objects, "node_listings": node_listings,
+            });
+            let data = serde_json::to_vec(&evidence)?;
+            if data.len() > 1024 * 1024 {
+                return Err("scanner/heal oracle exceeds the 1 MiB artifact budget".into());
+            }
+            let mut output = std::fs::OpenOptions::new()
+                .write(true)
+                .create_new(true)
+                .open(directory.join("background-target-restart.json"))?;
+            output.write_all(&data)?;
+            output.sync_all()?;
+        }
+
         Ok(())
     }
 

crates/e2e_test/src/on_demand_migration/concurrency_test.rs

@@ -20,10 +20,9 @@
 //! journal (`count_requests`) carries the assertion in every one of them.
 
 use super::common::{BoxError, OdmTestEnv, RawResponse, SeedObject, start_configured_env};
-use crate::fake_s3_target::{FaultAction, Operation};
+use crate::fake_s3_target::Operation;
 use aws_sdk_s3::types::{BucketVersioningStatus, VersioningConfiguration};
 use bytes::Bytes;
-use futures::{StreamExt, TryStreamExt};
 use std::time::Duration;
 
 type TestResult = Result<(), BoxError>;
@@ -146,38 +145,14 @@ async fn test_odm_range_burst_overflows_the_pull_queue_without_failing_clients()
     .await?;
 
     let body = payload(128 * 1024);
-    let blocker = "queue/blocker.bin";
-    env.seed_source(SOURCE_BUCKET, &[SeedObject::new(blocker, body.clone())]);
-    // The one-chunk range completes immediately; its full background pull
-    // occupies the only slot while the remaining requests fill the queue.
-    env.source.inject_for_key(
-        Operation::GetObject,
-        blocker,
-        FaultAction::SlowSendBody {
-            chunk_bytes: 1024,
-            delay: Duration::from_millis(100),
-        },
-        2,
-    );
-    let response = env
-        .raw_object_request(http::Method::GET, bucket, blocker, &[("range", "bytes=0-1023")])
-        .await?;
-    assert_eq!(response.status, 206);
-    assert_eq!(response.body, body.slice(0..1024));
-    env.wait_for_status_counter(bucket, "/inflight_pulls", 1, SETTLE).await?;
-
     let keys: Vec<String> = (0..REQUESTS).map(|index| format!("queue/object-{index:03}.bin")).collect();
     let seeds: Vec<SeedObject> = keys.iter().map(|key| SeedObject::new(key.clone(), body.clone())).collect();
     env.seed_source(SOURCE_BUCKET, &seeds);
 
-    // Bound source connections below the fixture's limit while still
-    // submitting all 100 requests to the eight-slot background queue.
-    let responses: Vec<RawResponse> = futures::stream::iter(
+    let responses: Vec<RawResponse> = futures::future::try_join_all(
         keys.iter()
             .map(|key| env.raw_object_request(http::Method::GET, bucket, key, &[("range", "bytes=0-1023")])),
     )
-    .buffered(16)
-    .try_collect()
     .await?;
     for (key, response) in keys.iter().zip(&responses) {
         assert_eq!(response.status, 206, "{key}: {}", String::from_utf8_lossy(&response.body));
@@ -193,15 +168,6 @@ async fn test_odm_range_burst_overflows_the_pull_queue_without_failing_clients()
         .wait_for_status_counter(bucket, "/counters/pull_failures_total/queue_full", 1, SETTLE)
         .await?;
     assert!(queue_full > 0, "a 100-deep burst must overflow an 8-slot queue");
-    let queue_full = usize::try_from(queue_full)?;
-    assert!(queue_full <= REQUESTS);
-    env.wait_for_status_counter(
-        bucket,
-        "/counters/pulled_objects_total/background",
-        u64::try_from(REQUESTS + 1 - queue_full)?,
-        SETTLE,
-    )
-    .await?;
 
     let ranged_reads: usize = keys.iter().map(|key| source_get_count(&env, key)).sum();
     assert!(
@@ -209,6 +175,9 @@ async fn test_odm_range_burst_overflows_the_pull_queue_without_failing_clients()
         "every reader is served from the source: {ranged_reads} GETs for {REQUESTS} readers"
     );
     let dropped = keys.iter().filter(|key| source_get_count(&env, key) == 1).count();
-    assert_eq!(dropped, queue_full, "only overflowed keys remain without a background GET");
+    assert!(
+        dropped > 0,
+        "the overflowed keys are the ones with no backfill GET, but every key got one"
+    );
     Ok(())
 }

crates/e2e_test/src/on_demand_migration/list_through_test.rs

@@ -265,13 +265,16 @@ async fn list_through_rejects_a_tampered_continuation_token() -> TestResult {
     let decoded = String::from_utf8(base64_simd::STANDARD.decode_to_vec(token.as_bytes())?)?;
     assert!(decoded.contains("\"t\":\"odm-list\""), "the merged token is an envelope: {decoded}");
 
-    let tampered = base64_simd::STANDARD.encode_to_string(decoded.replace("\"v\":1", "\"v\":3").as_bytes());
-    assert_ne!(tampered, token, "the test must change the token version");
-    let query = serde_urlencoded::to_string([("continuation-token", tampered.as_str())])?;
-    let rejected = env.raw_list_objects_v2(bucket, &query).await?;
-    let error_body = String::from_utf8_lossy(&rejected.body);
-    assert_eq!(rejected.status, 400, "a bumped token version is a client error: {}", error_body);
-    assert!(error_body.contains("<Code>InvalidArgument</Code>"), "{error_body}");
+    let tampered = base64_simd::STANDARD.encode_to_string(decoded.replace("\"v\":1", "\"v\":2").as_bytes());
+    let rejected = env
+        .raw_list_objects_v2(bucket, &format!("continuation-token={tampered}"))
+        .await?;
+    assert_eq!(
+        rejected.status,
+        400,
+        "a bumped token version is a client error: {}",
+        String::from_utf8_lossy(&rejected.body)
+    );
     Ok(())
 }
 

crates/e2e_test/src/upgrade_compatibility_test.rs

@@ -12,34 +12,21 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::common::{
-    RustFSTestClusterEnvironment, RustFSTestEnvironment, admin_request, init_logging, replication_fast_env, rustfs_binary_path,
-};
-use crate::fake_s3_target::{BucketMode, FAKE_ACCESS_KEY, FAKE_SECRET_KEY, FakeS3Target};
-use crate::on_demand_migration::common::{ODM_SERVER_ENV, OdmTestEnv, SeedObject};
-use crate::replication_extension_test::{
-    LOOPBACK_REPLICATION_TARGET_ENV, ReplicationTargetOptions, put_bucket_replication, set_replication_target_with_options,
-};
+use crate::common::{RustFSTestClusterEnvironment, RustFSTestEnvironment, init_logging, rustfs_binary_path};
 use aws_sdk_s3::Client;
 use aws_sdk_s3::error::ProvideErrorMetadata;
 use aws_sdk_s3::primitives::ByteStream;
 use aws_sdk_s3::types::{
-    BucketLifecycleConfiguration, BucketVersioningStatus, CompletedMultipartUpload, CompletedPart, DefaultRetention,
-    ExpirationStatus, LifecycleExpiration, LifecycleRule, LifecycleRuleFilter, ObjectLockConfiguration, ObjectLockEnabled,
-    ObjectLockRetentionMode, ObjectLockRule, PublicAccessBlockConfiguration, ServerSideEncryption, ServerSideEncryptionByDefault,
-    ServerSideEncryptionConfiguration, ServerSideEncryptionRule, Tag, Tagging, VersioningConfiguration,
+    BucketVersioningStatus, CompletedMultipartUpload, CompletedPart, ServerSideEncryption, VersioningConfiguration,
 };
-use http::{Method, StatusCode};
 use std::path::{Path, PathBuf};
 use std::time::Duration;
 use tokio::task::JoinSet;
 use tokio::time::{Instant, sleep};
 
 type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;
-type BoxError = Box<dyn std::error::Error + Send + Sync>;
 
 const SOURCE_BINARY_ENV: &str = "RUSTFS_UPGRADE_SOURCE_BINARY";
-const RC5_COMMIT: &str = "40a2470feb567201165a5b809b7598bb4b1f68f5";
 const SSE_MASTER_KEY_ENV: &str = "RUSTFS_SSE_S3_MASTER_KEY";
 const SSE_MASTER_KEY: &str = "QkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkJCQkI=";
 const PLAIN_BUCKET: &str = "upgrade-plain-data";
@@ -53,32 +40,6 @@ const MULTIPART_UPLOADS_PER_WORKER: usize = 16;
 // comfortably covers that window plus CI scheduling jitter.
 const LISTING_CONVERGENCE_TIMEOUT: Duration = Duration::from_secs(30);
 
-// Bucket-configuration upgrade/rollback scenarios (rustfs#7172, #7183, #7089).
-const CONFIG_PLAIN_BUCKET: &str = "upgrade-config-plain";
-const CONFIG_ENCRYPTED_BUCKET: &str = "upgrade-config-encrypted";
-const CONFIG_REPLICATED_BUCKET: &str = "upgrade-config-replicated";
-const CONFIG_LOCKED_BUCKET: &str = "upgrade-config-locked";
-const CONFIG_REPLICA_BUCKET: &str = "upgrade-config-replica";
-const ROLLBACK_BUCKET: &str = "rollback-config-data";
-const ROLLBACK_REPLICA_BUCKET: &str = "rollback-config-replica";
-const BUCKET_QUOTA_BYTES: u64 = 64 * 1024 * 1024;
-const LIFECYCLE_RULE_ID: &str = "upgrade-expire-logs";
-const LIFECYCLE_PREFIX: &str = "logs/";
-const LIFECYCLE_DAYS: i32 = 30;
-const BUCKET_TAG_KEY: &str = "owner";
-const BUCKET_TAG_VALUE: &str = "upgrade-compatibility";
-const OBJECT_LOCK_DAYS: i32 = 1;
-// `set-bucket-quota` answers 503 until the scanner has made the bucket's usage
-// authoritative; the quota test uses the same 30s budget.
-const QUOTA_READINESS_TIMEOUT: Duration = Duration::from_secs(30);
-// Quota admission fails closed while a freshly started server has neither
-// authoritative usage nor a persisted degraded baseline for the bucket
-// (rustfs#5716), so a write to a quota-enabled bucket is retryable-503 for that
-// window. It is a restart property, not an upgrade property — the same window
-// opens on the very first start — so the write assertions ride it out instead
-// of treating it as an upgrade failure.
-const QUOTA_ADMISSION_WARMUP_TIMEOUT: Duration = Duration::from_secs(90);
-
 fn source_binary() -> Result<PathBuf, Box<dyn std::error::Error + Send + Sync>> {
     let path = std::env::var_os(SOURCE_BINARY_ENV)
         .map(PathBuf::from)
@@ -279,93 +240,6 @@ async fn exercise_mixed_cluster(
     Ok(())
 }
 
-/// Pins the published old writer's limitation and the supported recovery
-/// procedure. This is not a promise that mixed-version ODM is supported.
-/// Replace the loss assertion when ODM gains independent persistence;
-/// preserving configuration across rc.5 writes is then an improvement.
-#[tokio::test]
-#[ignore = "requires the pinned 1.0.0-rc.5 release binary"]
-async fn rc5_rollback_requires_restoring_odm_configuration() -> TestResult {
-    init_logging();
-    let previous_binary = source_binary()?;
-    let version = tokio::process::Command::new(&previous_binary)
-        .arg("--version")
-        .output()
-        .await?;
-    assert!(version.status.success(), "previous binary must report its version");
-    assert!(
-        String::from_utf8(version.stdout)?.contains(RC5_COMMIT),
-        "this compatibility scenario requires the published rc.5 writer"
-    );
-    let mut env = OdmTestEnv::start().await?;
-    let bucket = "odm-rc5-rollback";
-    let source_bucket = "odm-rc5-source";
-    env.source.create_bucket_with_mode(source_bucket, BucketMode::Unversioned);
-    env.seed_source(
-        source_bucket,
-        &[SeedObject::new(
-            "source-only",
-            bytes::Bytes::from_static(b"source read after recovery"),
-        )],
-    );
-    env.rustfs.create_test_bucket(bucket).await?;
-    let saved_config = env.fake_source_spec(source_bucket);
-    assert_eq!(env.configure_source(bucket, &saved_config).await?.status, 200);
-    let before = env.get_config(bucket).await?;
-    assert_eq!(before.status, 200);
-    let expected_config = before
-        .json()?
-        .get("config")
-        .cloned()
-        .ok_or("configuration response omitted config")?;
-    env.client
-        .put_object()
-        .bucket(bucket)
-        .key("local")
-        .body(ByteStream::from_static(b"local data survives rollback"))
-        .send()
-        .await?;
-    env.rustfs.restart_server_preserving_data(vec![], ODM_SERVER_ENV).await?;
-    let restarted = env.get_config(bucket).await?;
-    assert_eq!(restarted.status, 200, "a current writer preserves ODM across restart");
-    assert_eq!(restarted.json()?.get("config"), Some(&expected_config));
-
-    restart_from_binary(&mut env.rustfs, &previous_binary, &[]).await?;
-    env.client
-        .put_bucket_tagging()
-        .bucket(bucket)
-        .tagging(
-            Tagging::builder()
-                .tag_set(Tag::builder().key("writer").value("rc5").build()?)
-                .build()?,
-        )
-        .send()
-        .await?;
-    env.rustfs.restart_server_preserving_data(vec![], ODM_SERVER_ENV).await?;
-    let missing = env.get_config(bucket).await?;
-    assert_eq!(missing.status, 404, "rc.5 rewrites metadata without ODM keys");
-    assert!(missing.body.contains("NoSuchConfiguration"));
-    assert_eq!(read_object(&env.client, bucket, "local", None).await?.1, b"local data survives rollback");
-    let tags = env.client.get_bucket_tagging().bucket(bucket).send().await?;
-    assert!(tags.tag_set().iter().any(|tag| tag.key() == "writer" && tag.value() == "rc5"));
-
-    assert_eq!(
-        env.configure_source(bucket, &saved_config).await?.status,
-        200,
-        "restore from saved full configuration"
-    );
-    env.rustfs.restart_server_preserving_data(vec![], ODM_SERVER_ENV).await?;
-    let restored = env.get_config(bucket).await?;
-    assert_eq!(restored.status, 200, "restored ODM configuration persists");
-    assert_eq!(restored.json()?.get("config"), Some(&expected_config));
-    env.wait_until_source_consulted(bucket).await?;
-    assert_eq!(
-        read_object(&env.client, bucket, "source-only", None).await?.1,
-        b"source read after recovery"
-    );
-    Ok(())
-}
-
 #[tokio::test]
 #[ignore = "requires a pinned previous RustFS release binary"]
 async fn direct_upgrade_from_rc2_preserves_object_contracts() -> TestResult {
@@ -555,653 +429,3 @@ async fn rolling_upgrade_from_rc2_preserves_mixed_version_contracts() -> TestRes
 
     Ok(())
 }
-
-/// Child-process environment shared by both bucket-configuration scenarios.
-///
-/// The replication target is an in-process fake bound to `127.0.0.1`, which
-/// `set-remote-target` rejects as an SSRF risk without the loopback opt-in, and
-/// the proxy bypass keeps a developer's `HTTP_PROXY` from intercepting the
-/// server's outbound health check.
-fn bucket_config_server_env() -> Vec<(&'static str, &'static str)> {
-    let mut env = vec![
-        (SSE_MASTER_KEY_ENV, SSE_MASTER_KEY),
-        ("NO_PROXY", "127.0.0.1,localhost"),
-        ("HTTP_PROXY", ""),
-        ("HTTPS_PROXY", ""),
-        // Shorten the scanner cycle so the bucket's usage becomes authoritative
-        // in seconds; both `set-bucket-quota` and quota admission block on it.
-        ("RUSTFS_SCANNER_CYCLE", "1"),
-        ("RUSTFS_SCANNER_START_DELAY_SECS", "0"),
-    ];
-    env.extend_from_slice(LOOPBACK_REPLICATION_TARGET_ENV);
-    env.extend(replication_fast_env());
-    env
-}
-
-/// Restart `env` in place on the same data directory using an explicit binary.
-///
-/// [`RustFSTestEnvironment::restart_server_preserving_data`] always relaunches
-/// the workspace build, which is the upgrade direction only. The rollback
-/// scenario needs the reverse: stop the current build and bring the pinned
-/// previous release up on the metadata that build just wrote.
-async fn restart_from_binary(env: &mut RustFSTestEnvironment, binary: &Path, server_env: &[(&str, &str)]) -> TestResult {
-    env.stop_server();
-    env.start_rustfs_server_from_binary(binary, vec![], server_env).await
-}
-
-async fn set_bucket_quota(env: &RustFSTestEnvironment, bucket: &str, quota_bytes: u64) -> TestResult {
-    let path = format!("/rustfs/admin/v3/quota/{bucket}");
-    let body = serde_json::json!({ "quota": quota_bytes, "quota_type": "HARD" }).to_string();
-    let deadline = Instant::now() + QUOTA_READINESS_TIMEOUT;
-    loop {
-        let (status, response) =
-            admin_request(&env.url, Method::PUT, &path, Some(body.clone()), &env.access_key, &env.secret_key).await?;
-        if status.is_success() {
-            return Ok(());
-        }
-        if status != StatusCode::SERVICE_UNAVAILABLE || Instant::now() >= deadline {
-            return Err(format!("setting the quota of {bucket} failed: {status} {response}").into());
-        }
-        sleep(Duration::from_millis(500)).await;
-    }
-}
-
-/// PUT into a quota-enabled bucket, riding out the post-start quota-admission
-/// warm-up described on [`QUOTA_ADMISSION_WARMUP_TIMEOUT`].
-///
-/// Only `ServiceUnavailable` is retried: any other failure, and a warm-up that
-/// never ends, is a genuine regression and surfaces as an error.
-async fn put_object_through_quota_warmup(client: &Client, bucket: &str, key: &str, body: &'static [u8]) -> TestResult {
-    let deadline = Instant::now() + QUOTA_ADMISSION_WARMUP_TIMEOUT;
-    loop {
-        let result = client
-            .put_object()
-            .bucket(bucket)
-            .key(key)
-            .body(ByteStream::from_static(body))
-            .send()
-            .await;
-        let error = match result {
-            Ok(_) => return Ok(()),
-            Err(error) => error,
-        };
-        let retryable = error.as_service_error().and_then(ProvideErrorMetadata::code) == Some("ServiceUnavailable");
-        if !retryable || Instant::now() >= deadline {
-            return Err(format!("PUT {bucket}/{key} failed after the quota warm-up window: {error}").into());
-        }
-        sleep(Duration::from_millis(500)).await;
-    }
-}
-
-async fn get_bucket_quota(env: &RustFSTestEnvironment, bucket: &str) -> Result<Option<u64>, BoxError> {
-    let path = format!("/rustfs/admin/v3/quota/{bucket}");
-    let (status, response) = admin_request(&env.url, Method::GET, &path, None, &env.access_key, &env.secret_key).await?;
-    if status != StatusCode::OK {
-        return Err(format!("reading the quota of {bucket} failed: {status} {response}").into());
-    }
-    let quota: serde_json::Value = serde_json::from_str(&response)?;
-    Ok(quota.get("quota").and_then(serde_json::Value::as_u64))
-}
-
-/// `GET /rustfs/admin/v3/list-remote-targets?bucket=...`.
-///
-/// Returns an error for any non-200, because rustfs#7172 made this endpoint
-/// fail closed on a `bucket-targets.json` blob the running build cannot parse.
-/// An upgrade that misreads a blob written by the previous release therefore
-/// shows up here as an error, and a silently dropped target shows up as an
-/// empty list — the caller must distinguish the two.
-async fn list_remote_targets(env: &RustFSTestEnvironment, bucket: &str) -> Result<Vec<serde_json::Value>, BoxError> {
-    let path = format!("/rustfs/admin/v3/list-remote-targets?bucket={}", urlencoding::encode(bucket));
-    let (status, response) = admin_request(&env.url, Method::GET, &path, None, &env.access_key, &env.secret_key).await?;
-    if status != StatusCode::OK {
-        return Err(format!("list-remote-targets for {bucket} failed: {status} {response}").into());
-    }
-    Ok(serde_json::from_str(&response)?)
-}
-
-/// Assert that `bucket` still carries exactly the replication target `arn`.
-async fn assert_remote_target_preserved(env: &RustFSTestEnvironment, bucket: &str, arn: &str, context: &str) -> TestResult {
-    let targets = list_remote_targets(env, bucket).await?;
-    assert_eq!(
-        targets.len(),
-        1,
-        "{context}: list-remote-targets must still report the single configured target, got {targets:?}"
-    );
-    assert_eq!(
-        targets[0].get("arn").and_then(serde_json::Value::as_str),
-        Some(arn),
-        "{context}: the target ARN changed across the restart: {targets:?}"
-    );
-    Ok(())
-}
-
-/// Configure a replication target on `bucket` pointing at the in-process fake,
-/// then attach an enabled replication rule for it. Returns the target ARN.
-async fn configure_replication(
-    env: &RustFSTestEnvironment,
-    bucket: &str,
-    target: &FakeS3Target,
-    target_bucket: &str,
-) -> Result<String, BoxError> {
-    let arn = set_replication_target_with_options(
-        env,
-        bucket,
-        ReplicationTargetOptions {
-            endpoint: &target.address(),
-            access_key: FAKE_ACCESS_KEY,
-            secret_key: FAKE_SECRET_KEY,
-            target_bucket,
-            secure: false,
-            skip_tls_verify: false,
-            ca_cert_pem: None,
-        },
-    )
-    .await?;
-    put_bucket_replication(env, bucket, &arn).await?;
-    Ok(arn)
-}
-
-async fn put_default_sse_s3_encryption(client: &Client, bucket: &str) -> TestResult {
-    let configuration = ServerSideEncryptionConfiguration::builder()
-        .rules(
-            ServerSideEncryptionRule::builder()
-                .apply_server_side_encryption_by_default(
-                    ServerSideEncryptionByDefault::builder()
-                        .sse_algorithm(ServerSideEncryption::Aes256)
-                        .build()?,
-                )
-                .build(),
-        )
-        .build()?;
-    client
-        .put_bucket_encryption()
-        .bucket(bucket)
-        .server_side_encryption_configuration(configuration)
-        .send()
-        .await?;
-    Ok(())
-}
-
-async fn assert_default_sse_s3_encryption(client: &Client, bucket: &str, context: &str) -> TestResult {
-    let response = client.get_bucket_encryption().bucket(bucket).send().await?;
-    let rules = response
-        .server_side_encryption_configuration()
-        .ok_or("GetBucketEncryption omitted the configuration")?
-        .rules();
-    assert_eq!(rules.len(), 1, "{context}: expected exactly one encryption rule, got {rules:?}");
-    assert_eq!(
-        rules[0]
-            .apply_server_side_encryption_by_default()
-            .map(ServerSideEncryptionByDefault::sse_algorithm),
-        Some(&ServerSideEncryption::Aes256),
-        "{context}: the default encryption algorithm changed"
-    );
-    Ok(())
-}
-
-async fn put_bucket_tag(client: &Client, bucket: &str) -> TestResult {
-    let tagging = Tagging::builder()
-        .tag_set(Tag::builder().key(BUCKET_TAG_KEY).value(BUCKET_TAG_VALUE).build()?)
-        .build()?;
-    client.put_bucket_tagging().bucket(bucket).tagging(tagging).send().await?;
-    Ok(())
-}
-
-async fn assert_bucket_tag(client: &Client, bucket: &str, context: &str) -> TestResult {
-    let tags = client.get_bucket_tagging().bucket(bucket).send().await?;
-    let tag_set = tags.tag_set();
-    assert_eq!(tag_set.len(), 1, "{context}: expected exactly one bucket tag, got {tag_set:?}");
-    assert_eq!(tag_set[0].key(), BUCKET_TAG_KEY, "{context}: bucket tag key changed");
-    assert_eq!(tag_set[0].value(), BUCKET_TAG_VALUE, "{context}: bucket tag value changed");
-    Ok(())
-}
-
-async fn assert_versioning_enabled(client: &Client, bucket: &str, context: &str) -> TestResult {
-    let versioning = client.get_bucket_versioning().bucket(bucket).send().await?;
-    assert_eq!(
-        versioning.status(),
-        Some(&BucketVersioningStatus::Enabled),
-        "{context}: versioning is no longer Enabled on {bucket}"
-    );
-    Ok(())
-}
-
-fn bucket_policy_document(bucket: &str) -> serde_json::Value {
-    serde_json::json!({
-        "Version": "2012-10-17",
-        "Statement": [{
-            "Sid": "UpgradePublicRead",
-            "Effect": "Allow",
-            "Principal": { "AWS": ["*"] },
-            "Action": ["s3:GetObject"],
-            "Resource": [format!("arn:aws:s3:::{bucket}/public/*")]
-        }]
-    })
-}
-
-/// `GET .../on-demand-migration/{bucket}/status`.
-///
-/// The migration module defaults on from rustfs#7089, so a bucket that never
-/// configured a source must still answer `configured: false` rather than
-/// engaging the migration path.
-async fn assert_migration_not_configured(env: &RustFSTestEnvironment, bucket: &str) -> TestResult {
-    let path = format!("/rustfs/admin/v3/on-demand-migration/{bucket}/status");
-    let (status, response) = admin_request(&env.url, Method::GET, &path, None, &env.access_key, &env.secret_key).await?;
-    assert_eq!(
-        status,
-        StatusCode::OK,
-        "the migration status endpoint must answer for an unconfigured bucket: {status} {response}"
-    );
-    let body: serde_json::Value = serde_json::from_str(&response)?;
-    assert_eq!(
-        body.get("configured"),
-        Some(&serde_json::Value::Bool(false)),
-        "a bucket upgraded from the previous release must not look migration-configured: {body}"
-    );
-    Ok(())
-}
-
-/// A GET for a key that was never written must be a plain `NoSuchKey`.
-///
-/// With the migration module on by default this is the cheap proof that an
-/// unconfigured bucket never consults a source: any migration engagement would
-/// surface as a different status or error code here.
-async fn assert_missing_key_is_no_such_key(client: &Client, bucket: &str, key: &str) -> TestResult {
-    let error = client
-        .get_object()
-        .bucket(bucket)
-        .key(key)
-        .send()
-        .await
-        .expect_err("a key that was never written must not be readable");
-    assert_eq!(
-        error.raw_response().map(|response| response.status().as_u16()),
-        Some(404),
-        "a missing key must stay a 404 on a bucket with no migration configuration"
-    );
-    assert_eq!(
-        error.as_service_error().and_then(ProvideErrorMetadata::code),
-        Some("NoSuchKey"),
-        "a missing key must stay NoSuchKey on a bucket with no migration configuration"
-    );
-    Ok(())
-}
-
-/// Bucket configuration written by the pinned previous release must survive an
-/// upgrade to the current build unchanged, and must keep working.
-///
-/// This pins the three on-disk surfaces the on-demand-migration series moved:
-///
-/// * `BucketMetadata` grew two msgpack keys (encoded map length 44 -> 46), so
-///   every configuration read below decodes a 44-key blob on 46-key code.
-/// * rustfs#7172 made an unreadable `bucket-targets.json` / encryption /
-///   public-access-block / quota blob "present but unreadable" instead of
-///   silently defaulting, and made `list-remote-targets` fail closed on it. A
-///   replication target configured by the old release must therefore still be
-///   *listed*, not dropped and not an error.
-/// * rustfs#7183 made the object write path refuse a PUT when the bucket's
-///   encryption configuration cannot be read, so a misparsed SSE config would
-///   turn every PUT to that bucket into a 500.
-///
-/// Not covered on purpose: on-demand-migration configuration itself, which the
-/// previous release has no public API for — the reverse direction is asserted
-/// instead (an upgraded bucket reports `configured: false`).
-#[tokio::test]
-#[ignore = "requires a pinned previous RustFS release binary"]
-async fn direct_upgrade_from_previous_release_preserves_bucket_configuration() -> TestResult {
-    init_logging();
-    let previous_binary = source_binary()?;
-
-    // In-process: the fake target outlives both server processes, so the
-    // replication target stays reachable across the upgrade.
-    let replication_target = FakeS3Target::start().await?;
-    replication_target.create_bucket(CONFIG_REPLICA_BUCKET);
-
-    let mut env = RustFSTestEnvironment::new().await?;
-    let server_env = bucket_config_server_env();
-    env.start_rustfs_server_from_binary(&previous_binary, vec![], &server_env)
-        .await?;
-    let old_client = env.create_s3_client();
-
-    env.create_test_bucket(CONFIG_PLAIN_BUCKET).await?;
-    env.create_test_bucket(CONFIG_ENCRYPTED_BUCKET).await?;
-    env.create_test_bucket(CONFIG_REPLICATED_BUCKET).await?;
-    old_client
-        .create_bucket()
-        .bucket(CONFIG_LOCKED_BUCKET)
-        .object_lock_enabled_for_bucket(true)
-        .send()
-        .await?;
-
-    // Plain bucket: policy, tags, lifecycle, quota.
-    let policy = bucket_policy_document(CONFIG_PLAIN_BUCKET);
-    old_client
-        .put_bucket_policy()
-        .bucket(CONFIG_PLAIN_BUCKET)
-        .policy(policy.to_string())
-        .send()
-        .await?;
-    put_bucket_tag(&old_client, CONFIG_PLAIN_BUCKET).await?;
-    old_client
-        .put_bucket_lifecycle_configuration()
-        .bucket(CONFIG_PLAIN_BUCKET)
-        .lifecycle_configuration(
-            BucketLifecycleConfiguration::builder()
-                .rules(
-                    LifecycleRule::builder()
-                        .id(LIFECYCLE_RULE_ID)
-                        .status(ExpirationStatus::Enabled)
-                        .filter(LifecycleRuleFilter::builder().prefix(LIFECYCLE_PREFIX).build())
-                        .expiration(LifecycleExpiration::builder().days(LIFECYCLE_DAYS).build())
-                        .build()?,
-                )
-                .build()?,
-        )
-        .send()
-        .await?;
-    set_bucket_quota(&env, CONFIG_PLAIN_BUCKET, BUCKET_QUOTA_BYTES).await?;
-
-    // Encrypted bucket: SSE-S3 default encryption plus a fully restrictive
-    // public access block, both of which rustfs#7172 now fails closed on.
-    put_default_sse_s3_encryption(&old_client, CONFIG_ENCRYPTED_BUCKET).await?;
-    old_client
-        .put_public_access_block()
-        .bucket(CONFIG_ENCRYPTED_BUCKET)
-        .public_access_block_configuration(
-            PublicAccessBlockConfiguration::builder()
-                .block_public_acls(true)
-                .ignore_public_acls(true)
-                .block_public_policy(true)
-                .restrict_public_buckets(true)
-                .build(),
-        )
-        .send()
-        .await?;
-
-    // Replicated bucket: versioning, a validated remote target, a rule.
-    enable_versioning(&old_client, CONFIG_REPLICATED_BUCKET).await?;
-    let target_arn = configure_replication(&env, CONFIG_REPLICATED_BUCKET, &replication_target, CONFIG_REPLICA_BUCKET).await?;
-    assert_remote_target_preserved(&env, CONFIG_REPLICATED_BUCKET, &target_arn, "before the upgrade").await?;
-
-    // Object-lock bucket: a default GOVERNANCE retention on a fresh bucket.
-    old_client
-        .put_object_lock_configuration()
-        .bucket(CONFIG_LOCKED_BUCKET)
-        .object_lock_configuration(
-            ObjectLockConfiguration::builder()
-                .object_lock_enabled(ObjectLockEnabled::Enabled)
-                .rule(
-                    ObjectLockRule::builder()
-                        .default_retention(
-                            DefaultRetention::builder()
-                                .mode(ObjectLockRetentionMode::Governance)
-                                .days(OBJECT_LOCK_DAYS)
-                                .build(),
-                        )
-                        .build(),
-                )
-                .build(),
-        )
-        .send()
-        .await?;
-
-    let plain_key = "plain/written-by-previous";
-    let plain_bytes = b"plain object written by the previous RustFS release";
-    put_object_through_quota_warmup(&old_client, CONFIG_PLAIN_BUCKET, plain_key, plain_bytes).await?;
-
-    let encrypted_key = "encrypted/written-by-previous";
-    let encrypted_bytes = b"default-encrypted object written by the previous RustFS release";
-    old_client
-        .put_object()
-        .bucket(CONFIG_ENCRYPTED_BUCKET)
-        .key(encrypted_key)
-        .body(ByteStream::from_static(encrypted_bytes))
-        .send()
-        .await?;
-    assert_eq!(
-        read_object(&old_client, CONFIG_ENCRYPTED_BUCKET, encrypted_key, None)
-            .await?
-            .0,
-        Some(ServerSideEncryption::Aes256),
-        "the previous release must apply the bucket default encryption it just accepted"
-    );
-
-    // The multipart object lives in the default-encrypted bucket so the
-    // upgraded build has to reassemble parts *and* re-derive the object key.
-    let multipart_key = "encrypted/multipart-written-by-previous";
-    let multipart_parts = vec![vec![b'm'; 5 * 1024 * 1024], b"final multipart bytes".to_vec()];
-    let multipart_bytes = multipart_parts.concat();
-    write_multipart(&old_client, CONFIG_ENCRYPTED_BUCKET, multipart_key, &multipart_parts).await?;
-
-    let versioned_key = "versioned/written-by-previous";
-    let versioned_bytes = b"versioned object written by the previous RustFS release";
-    let versioned_id = old_client
-        .put_object()
-        .bucket(CONFIG_REPLICATED_BUCKET)
-        .key(versioned_key)
-        .body(ByteStream::from_static(versioned_bytes))
-        .send()
-        .await?
-        .version_id()
-        .ok_or("versioned PUT omitted version ID")?
-        .to_string();
-
-    env.restart_server_preserving_data(vec![], &server_env).await?;
-    let new_client = env.create_s3_client();
-
-    // Every configuration must read back unchanged on the upgraded build.
-    let upgraded_policy = new_client.get_bucket_policy().bucket(CONFIG_PLAIN_BUCKET).send().await?;
-    let upgraded_policy: serde_json::Value =
-        serde_json::from_str(upgraded_policy.policy().ok_or("GetBucketPolicy omitted the document")?)?;
-    assert_eq!(upgraded_policy, policy, "the bucket policy changed across the upgrade");
-    assert_bucket_tag(&new_client, CONFIG_PLAIN_BUCKET, "after the upgrade").await?;
-
-    let lifecycle = new_client
-        .get_bucket_lifecycle_configuration()
-        .bucket(CONFIG_PLAIN_BUCKET)
-        .send()
-        .await?;
-    let rules = lifecycle.rules();
-    assert_eq!(rules.len(), 1, "the lifecycle rule count changed across the upgrade: {rules:?}");
-    assert_eq!(rules[0].id(), Some(LIFECYCLE_RULE_ID));
-    assert_eq!(rules[0].status(), &ExpirationStatus::Enabled);
-    assert_eq!(
-        rules[0].expiration().and_then(LifecycleExpiration::days),
-        Some(LIFECYCLE_DAYS),
-        "the lifecycle expiration changed across the upgrade"
-    );
-
-    assert_eq!(
-        get_bucket_quota(&env, CONFIG_PLAIN_BUCKET).await?,
-        Some(BUCKET_QUOTA_BYTES),
-        "the bucket quota changed across the upgrade"
-    );
-
-    assert_default_sse_s3_encryption(&new_client, CONFIG_ENCRYPTED_BUCKET, "after the upgrade").await?;
-    let public_access_block = new_client
-        .get_public_access_block()
-        .bucket(CONFIG_ENCRYPTED_BUCKET)
-        .send()
-        .await?;
-    let public_access_block = public_access_block
-        .public_access_block_configuration()
-        .ok_or("GetPublicAccessBlock omitted the configuration")?;
-    assert_eq!(public_access_block.block_public_acls(), Some(true));
-    assert_eq!(public_access_block.ignore_public_acls(), Some(true));
-    assert_eq!(public_access_block.block_public_policy(), Some(true));
-    assert_eq!(public_access_block.restrict_public_buckets(), Some(true));
-
-    assert_versioning_enabled(&new_client, CONFIG_REPLICATED_BUCKET, "after the upgrade").await?;
-    // rustfs#7172: neither an empty list nor an error is acceptable here.
-    assert_remote_target_preserved(&env, CONFIG_REPLICATED_BUCKET, &target_arn, "after the upgrade").await?;
-    let replication = new_client
-        .get_bucket_replication()
-        .bucket(CONFIG_REPLICATED_BUCKET)
-        .send()
-        .await?;
-    let replication_rules = replication
-        .replication_configuration()
-        .ok_or("GetBucketReplication omitted the configuration")?
-        .rules();
-    assert_eq!(
-        replication_rules.len(),
-        1,
-        "the replication rule count changed across the upgrade: {replication_rules:?}"
-    );
-    assert_eq!(
-        replication_rules[0].destination().map(|destination| destination.bucket()),
-        Some(target_arn.as_str()),
-        "the replication rule no longer points at the configured target"
-    );
-
-    let object_lock = new_client
-        .get_object_lock_configuration()
-        .bucket(CONFIG_LOCKED_BUCKET)
-        .send()
-        .await?;
-    let object_lock = object_lock
-        .object_lock_configuration()
-        .ok_or("GetObjectLockConfiguration omitted the configuration")?;
-    assert_eq!(object_lock.object_lock_enabled(), Some(&ObjectLockEnabled::Enabled));
-    let retention = object_lock
-        .rule()
-        .and_then(ObjectLockRule::default_retention)
-        .ok_or("the object lock configuration lost its default retention")?;
-    assert_eq!(retention.mode(), Some(&ObjectLockRetentionMode::Governance));
-    assert_eq!(retention.days(), Some(OBJECT_LOCK_DAYS));
-
-    // rustfs#7183: a PUT into the default-encrypted bucket must still succeed
-    // and still come back encrypted.
-    let post_upgrade_encrypted_key = "encrypted/written-after-upgrade";
-    let post_upgrade_encrypted_bytes = b"default-encrypted object written by the current RustFS build";
-    new_client
-        .put_object()
-        .bucket(CONFIG_ENCRYPTED_BUCKET)
-        .key(post_upgrade_encrypted_key)
-        .body(ByteStream::from_static(post_upgrade_encrypted_bytes))
-        .send()
-        .await?;
-    let (encryption, body) = read_object(&new_client, CONFIG_ENCRYPTED_BUCKET, post_upgrade_encrypted_key, None).await?;
-    assert_eq!(
-        encryption,
-        Some(ServerSideEncryption::Aes256),
-        "a PUT after the upgrade lost the bucket default encryption"
-    );
-    assert_eq!(body, post_upgrade_encrypted_bytes);
-
-    let post_upgrade_plain_key = "plain/written-after-upgrade";
-    let post_upgrade_plain_bytes = b"plain object written by the current RustFS build";
-    put_object_through_quota_warmup(&new_client, CONFIG_PLAIN_BUCKET, post_upgrade_plain_key, post_upgrade_plain_bytes).await?;
-    let (encryption, body) = read_object(&new_client, CONFIG_PLAIN_BUCKET, post_upgrade_plain_key, None).await?;
-    assert_eq!(encryption, None, "a bucket without default encryption must not encrypt a PUT");
-    assert_eq!(body, post_upgrade_plain_bytes);
-
-    // Every object written by the previous release reads back byte-identical.
-    assert_eq!(read_object(&new_client, CONFIG_PLAIN_BUCKET, plain_key, None).await?.1, plain_bytes);
-    let (encryption, body) = read_object(&new_client, CONFIG_ENCRYPTED_BUCKET, encrypted_key, None).await?;
-    assert_eq!(encryption, Some(ServerSideEncryption::Aes256));
-    assert_eq!(body, encrypted_bytes);
-    let (encryption, body) = read_object(&new_client, CONFIG_ENCRYPTED_BUCKET, multipart_key, None).await?;
-    assert_eq!(encryption, Some(ServerSideEncryption::Aes256));
-    assert_eq!(body, multipart_bytes, "the multipart object did not survive the upgrade");
-    assert_eq!(
-        read_object(&new_client, CONFIG_REPLICATED_BUCKET, versioned_key, Some(&versioned_id))
-            .await?
-            .1,
-        versioned_bytes
-    );
-
-    // rustfs#7089: the migration module is on by default, but a bucket that
-    // never configured a source behaves exactly as before.
-    assert_migration_not_configured(&env, CONFIG_PLAIN_BUCKET).await?;
-    assert_missing_key_is_no_such_key(&new_client, CONFIG_PLAIN_BUCKET, "plain/never-written").await?;
-
-    replication_target.shutdown().await;
-    Ok(())
-}
-
-/// Rolling back to the pinned previous release must still read the bucket
-/// metadata the current build wrote.
-///
-/// This is the other half of the `BucketMetadata` 44 -> 46 key change: the
-/// current build writes a 46-key msgpack map with `OnDemandMigrationConfigJSON`
-/// and `OnDemandMigrationConfigUpdatedAt`, and the previous release's decoder
-/// has to skip those two unknown keys instead of failing the whole blob. If it
-/// did not, every configuration read below would come back empty or error and
-/// the rollback would silently discard the bucket's configuration.
-#[tokio::test]
-#[ignore = "requires a pinned previous RustFS release binary"]
-async fn rollback_to_previous_release_reads_current_bucket_metadata() -> TestResult {
-    init_logging();
-    let previous_binary = source_binary()?;
-
-    let replication_target = FakeS3Target::start().await?;
-    replication_target.create_bucket(ROLLBACK_REPLICA_BUCKET);
-
-    let mut env = RustFSTestEnvironment::new().await?;
-    let server_env = bucket_config_server_env();
-    env.start_rustfs_server_with_env(vec![], &server_env).await?;
-    let new_client = env.create_s3_client();
-
-    env.create_test_bucket(ROLLBACK_BUCKET).await?;
-    enable_versioning(&new_client, ROLLBACK_BUCKET).await?;
-    put_default_sse_s3_encryption(&new_client, ROLLBACK_BUCKET).await?;
-    put_bucket_tag(&new_client, ROLLBACK_BUCKET).await?;
-    let target_arn = configure_replication(&env, ROLLBACK_BUCKET, &replication_target, ROLLBACK_REPLICA_BUCKET).await?;
-    assert_remote_target_preserved(&env, ROLLBACK_BUCKET, &target_arn, "before the rollback").await?;
-
-    let single_key = "rollback/single";
-    let single_bytes = b"single-part object written by the current RustFS build";
-    let single_version = new_client
-        .put_object()
-        .bucket(ROLLBACK_BUCKET)
-        .key(single_key)
-        .body(ByteStream::from_static(single_bytes))
-        .send()
-        .await?
-        .version_id()
-        .ok_or("versioned PUT omitted version ID")?
-        .to_string();
-
-    let multipart_key = "rollback/multipart";
-    let multipart_parts = vec![vec![b'r'; 5 * 1024 * 1024], b"final rollback bytes".to_vec()];
-    let multipart_bytes = multipart_parts.concat();
-    write_multipart(&new_client, ROLLBACK_BUCKET, multipart_key, &multipart_parts).await?;
-
-    restart_from_binary(&mut env, &previous_binary, &server_env).await?;
-    let old_client = env.create_s3_client();
-
-    assert_versioning_enabled(&old_client, ROLLBACK_BUCKET, "after the rollback").await?;
-    assert_default_sse_s3_encryption(&old_client, ROLLBACK_BUCKET, "after the rollback").await?;
-    assert_bucket_tag(&old_client, ROLLBACK_BUCKET, "after the rollback").await?;
-    assert_remote_target_preserved(&env, ROLLBACK_BUCKET, &target_arn, "after the rollback").await?;
-
-    let (encryption, body) = read_object(&old_client, ROLLBACK_BUCKET, single_key, Some(&single_version)).await?;
-    assert_eq!(encryption, Some(ServerSideEncryption::Aes256));
-    assert_eq!(body, single_bytes);
-    let (encryption, body) = read_object(&old_client, ROLLBACK_BUCKET, multipart_key, None).await?;
-    assert_eq!(encryption, Some(ServerSideEncryption::Aes256));
-    assert_eq!(body, multipart_bytes, "the multipart object did not survive the rollback");
-
-    // A PUT on the rolled-back release must still honour the encryption
-    // configuration it decoded out of the current build's metadata blob.
-    let post_rollback_key = "rollback/written-after-rollback";
-    let post_rollback_bytes = b"object written by the previous RustFS release after the rollback";
-    old_client
-        .put_object()
-        .bucket(ROLLBACK_BUCKET)
-        .key(post_rollback_key)
-        .body(ByteStream::from_static(post_rollback_bytes))
-        .send()
-        .await?;
-    let (encryption, body) = read_object(&old_client, ROLLBACK_BUCKET, post_rollback_key, None).await?;
-    assert_eq!(
-        encryption,
-        Some(ServerSideEncryption::Aes256),
-        "the rolled-back release lost the bucket default encryption"
-    );
-    assert_eq!(body, post_rollback_bytes);
-
-    replication_target.shutdown().await;
-    Ok(())
-}

crates/ecstore/Cargo.toml

@@ -31,7 +31,6 @@ workspace = true
 
 [features]
 default = []
-gcs = ["dep:google-cloud-storage", "dep:google-cloud-auth"]
 # Compiles the controlled list-objects namespace-journal chaos injector into a
 # production binary (it is always available to tests). Off by default so the
 # RUSTFS_LIST_OBJECTS_NAMESPACE_JOURNAL_CHAOS_* env vars cannot rewrite journal
@@ -213,9 +212,10 @@ aws-smithy-runtime-api = { workspace = true, features = ["http-1x"] }
 parking_lot = { workspace = true }
 base64-simd.workspace = true
 serde_urlencoded.workspace = true
-google-cloud-storage = { workspace = true, optional = true }
-google-cloud-auth = { workspace = true, optional = true }
+google-cloud-storage = { workspace = true }
+google-cloud-auth = { workspace = true }
 faster-hex = { workspace = true }
+quick-xml = { workspace = true }
 ratelimit = { workspace = true }
 aws-smithy-http-client = { workspace = true, default-features = false, features = ["rustls-aws-lc"] }
 

crates/ecstore/src/api/mod.rs

@@ -146,23 +146,69 @@ pub mod bucket {
         };
     }
 
+    pub mod on_demand_migration {
+        pub use crate::bucket::on_demand_migration::{
+            ApplyOutcome, BREAKER_FAILURE_THRESHOLD, BREAKER_FAILURE_WINDOW, BREAKER_HALF_OPEN_MAX_PROBES, BREAKER_OPEN_DURATION,
+            Breaker, BreakerState, BreakerTransition, BreakerVerdict, BucketOdmState, GLOBAL_ON_DEMAND_MIGRATION_SYS, GaugeGuard,
+            LastSourceError, LatencyBucketSnapshot, NEGATIVE_CACHE_MAX_ENTRIES, NegativeCache, OdmBucketSnapshot, OdmLookup,
+            OdmOp, OdmOutcome, OdmStateError, OdmStats, OdmStatsSnapshot, OnDemandMigrationSys, PullError, PullFailureReason,
+            PullFollower, PullLeader, PullOutcome, PullPath, PullResult, PullSlot, SOURCE_LATENCY_BUCKET_BOUNDS_MS,
+            SourceLatencySnapshot, source_backend_spec, source_client_spec,
+        };
+        pub use crate::bucket::on_demand_migration::{
+            AzureSourceConfig, ConfigPublishHook, FilterConfig, GcsSourceConfig, HeadPolicy, ON_DEMAND_MIGRATION_CONFIG_HOOK,
+            ON_DEMAND_MIGRATION_CONFIG_VERSION, OnDemandMigrationConfig, OnDemandMigrationConfigError, PathStyle, PolicyConfig,
+            Provider, RangeGetPolicy, SourceConfig, SourceCredentials, SourceErrorPolicy, SourceTimeout, TlsConfig,
+            ValidationContext,
+        };
+        pub use crate::bucket::on_demand_migration::{
+            EnqueueOutcome, LocalObject, MAX_MULTIPART_PARTS, OdmWriteBack, PULL_MAX_RETRIES, PULL_RETRY_BASE_DELAYS,
+            PullCompletion, PullQueue, PullReason, PullSource, QueuedPullOutcome, SourceBody, SourceIdleGuard, WriteBackBody,
+            WriteBackError, WriteBackOutcome, WriteBackPart, WriteBackRequest, commit_inline, commit_inline_with,
+            idle_guarded_body,
+        };
+        pub use crate::bucket::on_demand_migration::{
+            FetchRequest, LIST_THROUGH_TOKEN_VERSION, ListEntryKey, ListPageError, ListThroughCursor, ListThroughMerger,
+            ListThroughToken, ListThroughTokenError, MAX_LIST_FETCHES_PER_SIDE, MAX_LIST_NO_PROGRESS_PAGES, MergeOutcome,
+            MergePick, MergeSide, SOURCE_LIST_MAX_RATE_WAIT, SOURCE_LIST_RATE_PER_SEC, SourceListPlan, SourceListRateLimiter,
+            decode_continuation_token, source_list_plan,
+        };
+        pub mod backfill {
+            pub use crate::bucket::on_demand_migration::backfill::{
+                BACKFILL_CHECKPOINT_FILE, BACKFILL_CHECKPOINT_FORMAT_VERSION, BACKFILL_FAILED_KEYS_CAPACITY, BACKFILL_LEASE,
+                BACKFILL_LEASE_LOCK_PREFIX, BACKFILL_LIST_PAGE_SIZE, BACKFILL_RECOVERY_INTERVAL, BACKFILL_SAVE_EVERY_KEYS,
+                BACKFILL_SAVE_INTERVAL, BackfillCheckpoint, BackfillContext, BackfillContextFactory, BackfillError,
+                BackfillLastError, BackfillOwner, BackfillRecoveryStats, BackfillRequest, BackfillRunner, BackfillState,
+                BucketBackfillContext, LocalBackfillObject, PriorityPullPermits, PullPermit, PullPriority, SkipExisting,
+                StoredCheckpoint, SysBackfillContexts, global_backfill_runner, install_global_backfill_runner, key_hash,
+                read_checkpoint, run_backfill_recovery_loop, spawn_backfill_recovery_loop,
+            };
+        }
+        pub mod source_client {
+            pub use crate::bucket::on_demand_migration::source_client::{
+                AzureAuth, AzureSourceSpec, GcsSourceSpec, SourceBackendSpec, SourceClient, SourceClientSpec, SourceError,
+                SourceGet, SourceHead, SourceListRequest, SourceObject, SourcePage, SourceProbe, SourceProvider, SourceSse,
+                SourceTimeouts, USER_AGENT_SUFFIX, is_multipart_etag, range_header_value, resolve_path_style,
+            };
+        }
+    }
+
     pub mod metadata_sys {
+        #[cfg(feature = "test-util")]
+        pub use crate::bucket::metadata_sys::ConfigWriteLockProbe;
         pub use crate::bucket::metadata_sys::{
-            BUCKET_CONFIG_PUBLISH_HOOK, BucketConfigPublishHook, BucketMetadataMutationGuard, BucketMetadataSys,
-            ObjectLockConfigState, acquire_bucket_metadata_transaction_lock,
+            BucketMetadataMutationGuard, BucketMetadataSys, ObjectLockConfigState, acquire_bucket_metadata_transaction_lock,
             acquire_bucket_metadata_transaction_lock_for_incarnation, acquire_scanner_bucket_incarnation_fence,
             capture_bucket_metadata_incarnation, delete, delete_if_incarnation, delete_under_transaction_lock, get,
             get_accelerate_config, get_bucket_policy, get_bucket_policy_raw, get_bucket_targets_config, get_config_from_disk,
             get_cors_config, get_durability_config, get_global_bucket_metadata_sys, get_lifecycle_config, get_logging_config,
             get_notification_config, get_object_lock_config, get_object_lock_config_state, get_on_demand_migration_config,
-            get_on_demand_migration_config_in, get_public_access_block_config, get_quota_config, get_replication_config,
-            get_request_payment_config, get_sse_config, get_tagging_config, get_versioning_config, get_website_config,
-            init_bucket_metadata_sys, list_bucket_targets, reload_bucket_metadata, remove_bucket_metadata, set_bucket_metadata,
-            update, update_bucket_targets_under_transaction_lock, update_config_with, update_if_incarnation,
-            update_quota_if_incarnation, update_under_transaction_lock,
+            get_public_access_block_config, get_quota_config, get_replication_config, get_request_payment_config, get_sse_config,
+            get_tagging_config, get_versioning_config, get_website_config, init_bucket_metadata_sys, list_bucket_targets,
+            reload_bucket_metadata, remove_bucket_metadata, set_bucket_metadata, update,
+            update_bucket_targets_under_transaction_lock, update_config_with, update_if_incarnation, update_quota_if_incarnation,
+            update_under_transaction_lock,
         };
-        #[cfg(feature = "test-util")]
-        pub use crate::bucket::metadata_sys::{ConfigWriteLockProbe, test_support};
     }
 
     pub mod migration {
@@ -205,7 +251,7 @@ pub mod bucket {
     pub mod remote_s3_client {
         pub use crate::bucket::remote_s3_client::{
             PathStyle, RemoteCredentials, RemoteS3ClientError, RemoteS3EndpointSpec, RemoteS3RetryPolicy, build_remote_s3_client,
-            build_remote_s3_config, validate_remote_endpoint, validate_target_ca_pem,
+            validate_remote_endpoint,
         };
     }
 
@@ -451,9 +497,9 @@ pub mod object {
         ObjectInfo, ObjectLockConfigSnapshot, ObjectMutationHook, ObjectOptions, PutObjReader, QuotaAdmission,
         RangedDecompressReader, ReadEncryptionMaterial, ReadEncryptionMode, ReadEncryptionRequest,
         SCANNER_PUBLICATION_LEASE_FENCE_METADATA_KEY, ScannerPublicationCommitScope, ScannerPublicationCommitStartError,
-        ScannerPublicationCommitState, StreamConsumer, WriteCompletion, get_object_body_cache_plaintext_len,
-        lookup_get_object_body_cache_hook, register_get_object_body_cache_hook, register_object_mutation_hook,
-        unregister_get_object_body_cache_hook, unregister_object_mutation_hook,
+        ScannerPublicationCommitState, StreamConsumer, get_object_body_cache_plaintext_len, lookup_get_object_body_cache_hook,
+        register_get_object_body_cache_hook, register_object_mutation_hook, unregister_get_object_body_cache_hook,
+        unregister_object_mutation_hook,
     };
     pub use crate::store::{
         PrepareSelectObjectSnapshotError, PreparedGetObjectReader, SelectObjectSnapshot, SelectObjectSnapshotReadError,

crates/ecstore/src/bucket/metadata.rs

@@ -489,17 +489,28 @@ impl BucketMetadata {
         !self.bucket_targets_config_json.is_empty() && self.bucket_target_config.is_none()
     }
 
-    /// Opaque application-owned configuration with its persisted update time.
-    /// Empty bytes mean absent or cleared; decoding belongs to the consumer.
-    pub fn on_demand_migration_config(&self) -> Option<(&[u8], OffsetDateTime)> {
-        (!self.on_demand_migration_config_json.is_empty()).then_some((
-            self.on_demand_migration_config_json.as_slice(),
-            self.on_demand_migration_config_updated_at,
-        ))
+    /// Parsed per-bucket durability override, if a valid one is stored.
+    ///
+    /// Absent/empty/unparsable payloads all mean "no override" (the bucket
+    /// follows the global durability mode); a parse failure is logged so a
+    /// corrupted entry cannot silently change fsync behavior.
+    /// Parsed on-demand migration config, if one is stored.
+    ///
+    /// `Ok(None)` means no config (absent or cleared). A stored payload that
+    /// does not parse is an error, never a default: the runtime must not
+    /// pull from a source it cannot describe.
+    pub fn on_demand_migration_config(
+        &self,
+    ) -> std::result::Result<
+        Option<super::on_demand_migration::OnDemandMigrationConfig>,
+        super::on_demand_migration::OnDemandMigrationConfigError,
+    > {
+        if self.on_demand_migration_config_json.is_empty() {
+            return Ok(None);
+        }
+        super::on_demand_migration::OnDemandMigrationConfig::from_json(&self.on_demand_migration_config_json).map(Some)
     }
 
-    /// Parsed per-bucket durability override, if a valid one is stored.
-    /// Invalid payloads follow the global mode after logging a parse failure.
     pub fn durability_config(&self) -> Option<super::durability::BucketDurabilityConfig> {
         if self.durability_config_json.is_empty() {
             return None;
@@ -905,6 +916,13 @@ impl BucketMetadata {
                 self.durability_config_updated_at = updated;
             }
             BUCKET_ON_DEMAND_MIGRATION_CONFIG => {
+                // Structural check only (shape, unknown fields); the
+                // deployment-relative rules run in the admin handler with a
+                // `ValidationContext`. A blob this build cannot read must not
+                // be persisted for every later reader to trip over.
+                if !data.is_empty() {
+                    super::on_demand_migration::OnDemandMigrationConfig::from_json(&data).map_err(Error::other)?;
+                }
                 self.on_demand_migration_config_json = data;
                 self.on_demand_migration_config_updated_at = updated;
             }
@@ -1960,30 +1978,51 @@ mod test {
 
     const ODM_JSON: &[u8] = br#"{"version":1,"enabled":true,"source":{"provider":"minio","endpoint":"https://legacy.example.com:9000","region":"auto","bucket":"legacy-bucket","credentials":{"access_key":"AK","secret_key":"SK"}}}"#;
 
-    /// The metadata codec preserves application-owned bytes and timestamps.
+    /// rustfs/backlog#2148: the on-demand migration config is a RustFS
+    /// extension entry that round-trips through `update_config` and the
+    /// msgpack codec, clears on delete, and never parses corruption into a
+    /// default.
     #[test]
     fn on_demand_migration_config_round_trips_and_tracks_updates() {
+        use crate::bucket::on_demand_migration::{OnDemandMigrationConfig, OnDemandMigrationConfigError};
+
         let mut bm = BucketMetadata::new("odm-bucket");
-        assert_eq!(bm.on_demand_migration_config(), None, "fresh metadata carries no config");
+        assert_eq!(bm.on_demand_migration_config(), Ok(None), "fresh metadata carries no config");
+
+        let expected = OnDemandMigrationConfig::from_json(ODM_JSON).unwrap();
         bm.update_config(BUCKET_ON_DEMAND_MIGRATION_CONFIG, ODM_JSON.to_vec())
-            .expect("opaque config is accepted");
-        let stamped = bm.on_demand_migration_config_updated_at;
-        assert_ne!(stamped, OffsetDateTime::UNIX_EPOCH);
-        assert_eq!(bm.on_demand_migration_config(), Some((ODM_JSON, stamped)));
+            .expect("valid config is accepted");
+        assert_ne!(bm.on_demand_migration_config_updated_at, OffsetDateTime::UNIX_EPOCH);
+        assert_eq!(bm.on_demand_migration_config(), Ok(Some(expected.clone())));
+
         let back = BucketMetadata::unmarshal(&bm.marshal_msg().unwrap()).unwrap();
         assert_eq!(back.on_demand_migration_config_json, bm.on_demand_migration_config_json);
-        assert_eq!(back.on_demand_migration_config_updated_at.unix_timestamp(), stamped.unix_timestamp());
+        assert_eq!(
+            back.on_demand_migration_config_updated_at.unix_timestamp(),
+            bm.on_demand_migration_config_updated_at.unix_timestamp()
+        );
+        assert_eq!(back.on_demand_migration_config(), Ok(Some(expected)));
+
+        // A blob this build cannot read is rejected at the write boundary
+        // rather than persisted for every reader to trip over.
+        let before = bm.on_demand_migration_config_json.clone();
+        assert!(
+            bm.update_config(BUCKET_ON_DEMAND_MIGRATION_CONFIG, br#"{"source":{"provider":"s3"},"bogus":1}"#.to_vec())
+                .is_err()
+        );
+        assert_eq!(bm.on_demand_migration_config_json, before, "a rejected update leaves the blob untouched");
+
+        // Delete clears the entry.
+        let stamped = bm.on_demand_migration_config_updated_at;
         bm.update_config(BUCKET_ON_DEMAND_MIGRATION_CONFIG, Vec::new()).unwrap();
         assert!(bm.on_demand_migration_config_json.is_empty());
-        assert_eq!(bm.on_demand_migration_config(), None);
+        assert_eq!(bm.on_demand_migration_config(), Ok(None));
         assert!(bm.on_demand_migration_config_updated_at >= stamped);
-        bm.update_config(BUCKET_ON_DEMAND_MIGRATION_CONFIG, b"not-json".to_vec())
-            .unwrap();
-        let back = BucketMetadata::unmarshal(&bm.marshal_msg().unwrap()).unwrap();
-        assert_eq!(
-            back.on_demand_migration_config_json, b"not-json",
-            "metadata must not reinterpret application bytes"
-        );
+
+        // Corruption that bypassed `update_config` (disk, another writer)
+        // is a typed error, never a default.
+        bm.on_demand_migration_config_json = b"not-json".to_vec();
+        assert!(matches!(bm.on_demand_migration_config(), Err(OnDemandMigrationConfigError::Malformed(_))));
     }
 
     /// rustfs/backlog#2148: a `.metadata.bin` written before the on-demand
@@ -1995,7 +2034,7 @@ mod test {
         let mut bm = BucketMetadata::unmarshal(&blob[4..]).expect("unmarshal MinIO bucket metadata");
         assert!(bm.on_demand_migration_config_json.is_empty());
         assert_eq!(bm.on_demand_migration_config_updated_at, OffsetDateTime::UNIX_EPOCH);
-        assert_eq!(bm.on_demand_migration_config(), None);
+        assert_eq!(bm.on_demand_migration_config(), Ok(None));
 
         bm.default_timestamps();
         assert_ne!(bm.created, OffsetDateTime::UNIX_EPOCH, "fixture must carry a real creation time");

crates/ecstore/src/bucket/metadata_sys.rs

@@ -19,6 +19,7 @@ use super::quota::BucketQuota;
 use super::target::BucketTargets;
 use crate::bucket::bucket_target_sys::BucketTargetSys;
 use crate::bucket::metadata::{load_bucket_metadata_parse, load_bucket_metadata_parse_with_presence};
+use crate::bucket::on_demand_migration::{ON_DEMAND_MIGRATION_CONFIG_HOOK, OnDemandMigrationConfig};
 use crate::bucket::utils::is_meta_bucketname;
 use crate::disk::RUSTFS_META_BUCKET;
 use crate::error::{Error, Result, is_err_bucket_not_found, is_err_strict_volume_not_found};
@@ -48,11 +49,6 @@ use tokio_util::sync::CancellationToken;
 use tracing::{error, warn};
 use uuid::Uuid;
 
-/// Opaque bucket configuration notifications for application-owned services.
-/// `None` withdraws a configuration; consumers validate nonempty bytes.
-pub type BucketConfigPublishHook = Box<dyn Fn(&str, &str, Option<(&[u8], OffsetDateTime, Uuid)>) + Send + Sync>;
-pub static BUCKET_CONFIG_PUBLISH_HOOK: std::sync::OnceLock<BucketConfigPublishHook> = std::sync::OnceLock::new();
-
 const BUCKET_METADATA_REFRESH_INTERVAL: Duration = Duration::from_secs(15 * 60);
 
 #[cfg(any(test, feature = "test-util"))]
@@ -399,21 +395,39 @@ fn clear_bucket_durability(bucket: &str) {
     crate::disk::local::bucket_durability::set(bucket, None);
 }
 
-/// Publish application-owned bytes on every cache install path.
+/// Publish the bucket's on-demand migration config (or its absence) to the
+/// runtime registered in `ON_DEMAND_MIGRATION_CONFIG_HOOK`.
+///
+/// Called from the same five cache-install paths as
+/// [`sync_bucket_durability`]. A stored payload this build cannot parse is
+/// published as `None`: the runtime must stop pulling for that bucket rather
+/// than keep an older config or guess.
 fn sync_on_demand_migration(bucket: &str, bm: &BucketMetadata) {
-    if let Some(hook) = BUCKET_CONFIG_PUBLISH_HOOK.get() {
-        hook(
-            bucket,
-            super::metadata::BUCKET_ON_DEMAND_MIGRATION_CONFIG,
-            bm.on_demand_migration_config()
-                .map(|(bytes, stamp)| (bytes, stamp, bm.bucket_incarnation_id)),
-        );
+    let Some(hook) = ON_DEMAND_MIGRATION_CONFIG_HOOK.get() else {
+        return;
+    };
+    match bm.on_demand_migration_config() {
+        Ok(config) => hook(bucket, config.as_ref()),
+        Err(err) => {
+            warn!(
+                event = "bucket_metadata_parse_failed",
+                component = "ecstore",
+                subsystem = "bucket_metadata",
+                bucket = %bucket,
+                config = "on_demand_migration",
+                error = %err,
+                "Failed to parse bucket metadata config"
+            );
+            hook(bucket, None);
+        }
     }
 }
 
+/// Withdraw a bucket's on-demand migration config when its metadata leaves
+/// the cache.
 fn clear_on_demand_migration(bucket: &str) {
-    if let Some(hook) = BUCKET_CONFIG_PUBLISH_HOOK.get() {
-        hook(bucket, super::metadata::BUCKET_ON_DEMAND_MIGRATION_CONFIG, None);
+    if let Some(hook) = ON_DEMAND_MIGRATION_CONFIG_HOOK.get() {
+        hook(bucket, None);
     }
 }
 
@@ -1035,21 +1049,15 @@ pub async fn get_durability_config(
 }
 
 /// The bucket's on-demand migration config with its update time, or
-/// `Ok(None)` when the bucket has none. Bytes are opaque to the metadata owner.
-pub async fn get_on_demand_migration_config(bucket: &str) -> Result<Option<(Vec<u8>, OffsetDateTime)>> {
+/// `Ok(None)` when the bucket has none. A stored payload that does not parse
+/// is a typed error (`OnDemandMigrationConfigError` inside `Error::Io`).
+pub async fn get_on_demand_migration_config(bucket: &str) -> Result<Option<(OnDemandMigrationConfig, OffsetDateTime)>> {
     let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
     let bucket_meta_sys = bucket_meta_sys_lock.read().await;
 
     bucket_meta_sys.get_on_demand_migration_config(bucket).await
 }
 
-/// Resolve opaque configuration from the store's own metadata system.
-pub async fn get_on_demand_migration_config_in(api: &ECStore, bucket: &str) -> Result<Option<(Vec<u8>, OffsetDateTime)>> {
-    let sys = bucket_metadata_sys_of(&api.ctx)?;
-    let lock = sys.read().await;
-    lock.get_on_demand_migration_config(bucket).await
-}
-
 pub async fn get_quota_config(bucket: &str) -> Result<(BucketQuota, OffsetDateTime)> {
     let bucket_meta_sys_lock = get_bucket_metadata_sys()?;
     let bucket_meta_sys = bucket_meta_sys_lock.read().await;
@@ -2571,27 +2579,29 @@ impl BucketMetadataSys {
     }
 
     /// See [`get_on_demand_migration_config`].
-    pub async fn get_on_demand_migration_config(&self, bucket: &str) -> Result<Option<(Vec<u8>, OffsetDateTime)>> {
+    pub async fn get_on_demand_migration_config(
+        &self,
+        bucket: &str,
+    ) -> Result<Option<(OnDemandMigrationConfig, OffsetDateTime)>> {
         let (bm, _) = self.get_config(bucket).await?;
 
-        Ok(bm
-            .on_demand_migration_config()
-            .map(|(bytes, updated_at)| (bytes.to_vec(), updated_at)))
+        let config = bm.on_demand_migration_config().map_err(Error::other)?;
+        Ok(config.map(|config| (config, bm.on_demand_migration_config_updated_at)))
     }
 }
 
 /// Test-only fixture shared with sibling modules (e.g. the quota checker
 /// tests): a 4-disk `ECStore` on an isolated instance context, so tests
 /// exercising the metadata system never touch ambient process state.
-#[cfg(any(test, feature = "test-util"))]
-pub mod test_support {
+#[cfg(test)]
+pub(crate) mod test_support {
     use super::*;
     use crate::disk::endpoint::Endpoint;
     use crate::layout::endpoints::{EndpointServerPools, Endpoints, PoolEndpoints};
     use crate::runtime::instance::InstanceContext;
     use crate::store::init_local_disks_with_instance_ctx;
 
-    pub async fn isolated_store_over_temp_disks() -> (Vec<tempfile::TempDir>, Arc<ECStore>) {
+    pub(crate) async fn isolated_store_over_temp_disks() -> (Vec<tempfile::TempDir>, Arc<ECStore>) {
         let mut dirs = Vec::with_capacity(4);
         let mut endpoints = Vec::with_capacity(4);
         for disk_idx in 0..4 {
@@ -4375,26 +4385,19 @@ mod tests {
 
     const ODM_JSON: &[u8] = br#"{"source":{"provider":"minio","endpoint":"https://legacy.example.com:9000","region":"auto","bucket":"legacy-bucket","credentials":{"access_key":"AK","secret_key":"SK"}}}"#;
 
-    type RecordedOdmConfig = Option<(Vec<u8>, OffsetDateTime, Uuid)>;
-    type RecordedOdmHookCall = (String, RecordedOdmConfig);
-
     /// Every `(bucket, config)` the recording hook has seen. Tests filter by
     /// their own bucket name; the hook is process-wide and set once.
-    static ODM_HOOK_CALLS: std::sync::Mutex<Vec<RecordedOdmHookCall>> = std::sync::Mutex::new(Vec::new());
+    static ODM_HOOK_CALLS: std::sync::Mutex<Vec<(String, Option<OnDemandMigrationConfig>)>> = std::sync::Mutex::new(Vec::new());
 
     fn install_recording_odm_hook() {
-        BUCKET_CONFIG_PUBLISH_HOOK.get_or_init(|| {
-            Box::new(|bucket, config_file, config| {
-                assert_eq!(config_file, super::super::metadata::BUCKET_ON_DEMAND_MIGRATION_CONFIG);
-                ODM_HOOK_CALLS.lock().unwrap().push((
-                    bucket.to_string(),
-                    config.map(|(bytes, stamp, incarnation)| (bytes.to_vec(), stamp, incarnation)),
-                ));
+        ON_DEMAND_MIGRATION_CONFIG_HOOK.get_or_init(|| {
+            Box::new(|bucket, config| {
+                ODM_HOOK_CALLS.lock().unwrap().push((bucket.to_string(), config.cloned()));
             })
         });
     }
 
-    fn odm_hook_calls(bucket: &str) -> Vec<RecordedOdmConfig> {
+    fn odm_hook_calls(bucket: &str) -> Vec<Option<OnDemandMigrationConfig>> {
         ODM_HOOK_CALLS
             .lock()
             .unwrap()
@@ -4404,6 +4407,54 @@ mod tests {
             .collect()
     }
 
+    /// rustfs/backlog#2148: the accessor reports absence as `Ok(None)` and a
+    /// stored payload it cannot parse as a typed error, never as a default
+    /// and never as `ConfigNotFound`.
+    #[tokio::test]
+    async fn get_on_demand_migration_config_distinguishes_absent_from_corrupt() {
+        use crate::bucket::on_demand_migration::OnDemandMigrationConfigError;
+
+        let (_dirs, ecstore) = isolated_store_over_temp_disks().await;
+        let sys = BucketMetadataSys::new(ecstore);
+        let bucket = "odm-accessor";
+
+        sys.set(bucket.to_string(), Arc::new(BucketMetadata::new(bucket))).await;
+        assert_eq!(sys.get_on_demand_migration_config(bucket).await.unwrap(), None);
+
+        let mut corrupt = BucketMetadata::new(bucket);
+        corrupt.on_demand_migration_config_json = br#"{"source":{"provider":"s3"},"bogus":1}"#.to_vec();
+        sys.set(bucket.to_string(), Arc::new(corrupt)).await;
+        let err = sys
+            .get_on_demand_migration_config(bucket)
+            .await
+            .expect_err("corrupt config must not read as a default");
+        assert_ne!(err, Error::ConfigNotFound, "corruption must not be reported as absence");
+        let typed = match &err {
+            Error::Io(io) => io
+                .get_ref()
+                .and_then(|source| source.downcast_ref::<OnDemandMigrationConfigError>()),
+            _ => None,
+        };
+        assert!(
+            matches!(typed, Some(OnDemandMigrationConfigError::Malformed(_))),
+            "typed parse error must survive the Result boundary, got: {err:?}"
+        );
+
+        let mut valid = BucketMetadata::new(bucket);
+        valid
+            .update_config(crate::bucket::metadata::BUCKET_ON_DEMAND_MIGRATION_CONFIG, ODM_JSON.to_vec())
+            .unwrap();
+        let stamped = valid.on_demand_migration_config_updated_at;
+        sys.set(bucket.to_string(), Arc::new(valid)).await;
+        let (config, updated_at) = sys
+            .get_on_demand_migration_config(bucket)
+            .await
+            .unwrap()
+            .expect("stored config is returned");
+        assert_eq!(config, OnDemandMigrationConfig::from_json(ODM_JSON).unwrap());
+        assert_eq!(updated_at, stamped);
+    }
+
     /// rustfs/backlog#2148: the publish hook fires on every path that
     /// installs bucket metadata into the cache (set, initial load, peer
     /// reload, refresh loop, lazy load) and withdraws on removal, mirroring
@@ -4417,22 +4468,15 @@ mod tests {
         for dir in &dirs {
             std::fs::create_dir_all(dir.path().join(bucket)).expect("physical bucket should exist");
         }
-
-        let incarnation = Uuid::new_v4();
+        let expected = OnDemandMigrationConfig::from_json(ODM_JSON).unwrap();
         let expect_publish = |before: usize, label: &str| {
             let calls = odm_hook_calls(bucket);
             assert_eq!(calls.len(), before + 1, "{label} must publish exactly once");
-            assert_eq!(
-                calls.last().unwrap().as_ref().map(|(bytes, _, _)| bytes.as_slice()),
-                Some(ODM_JSON),
-                "{label} must publish the stored bytes"
-            );
-            assert_eq!(calls.last().unwrap().as_ref().map(|(_, _, id)| *id), Some(incarnation));
+            assert_eq!(calls.last().unwrap().as_ref(), Some(&expected), "{label} must publish the stored config");
         };
 
         // set (via persist_new_and_set, which installs through `set`).
         let mut bm = BucketMetadata::new(bucket);
-        bm.bucket_incarnation_id = incarnation;
         bm.update_config(crate::bucket::metadata::BUCKET_ON_DEMAND_MIGRATION_CONFIG, ODM_JSON.to_vec())
             .unwrap();
         let writer = BucketMetadataSys::new(ecstore.clone());
@@ -4474,18 +4518,14 @@ mod tests {
         assert_eq!(calls.len(), before + 1, "remove must withdraw exactly once");
         assert_eq!(calls.last().unwrap(), &None);
 
-        // Opaque bytes reach the application even if they are not valid JSON.
+        // A corrupt payload is withdrawn, never published as a config.
         let mut corrupt = BucketMetadata::new(bucket);
         corrupt.on_demand_migration_config_json = b"not-json".to_vec();
         let before = odm_hook_calls(bucket).len();
         lazy.set(bucket.to_string(), Arc::new(corrupt)).await;
         let calls = odm_hook_calls(bucket);
         assert_eq!(calls.len(), before + 1);
-        assert_eq!(
-            calls.last().unwrap().as_ref().map(|(bytes, _, _)| bytes.as_slice()),
-            Some(b"not-json".as_slice()),
-            "the application validates opaque config bytes"
-        );
+        assert_eq!(calls.last().unwrap(), &None, "unreadable config must publish absence");
     }
 
     #[tokio::test]

crates/ecstore/src/bucket/mod.rs

@@ -26,6 +26,7 @@ mod metadata_test;
 pub mod migration;
 mod msgp_decode;
 pub mod object_lock;
+pub mod on_demand_migration;
 pub mod policy_sys;
 pub mod quota;
 pub mod remote_s3_client;

crates/ecstore/src/bucket/on_demand_migration/azure.rs

@@ -40,8 +40,8 @@ use super::source_client::{
     AzureAuth, AzureSourceSpec, SourceBackend, SourceError, SourceGet, SourceHead, SourceListRequest, SourceObject, SourcePage,
     SourceTimeouts, range_header_value,
 };
-use super::storage_api::HTTPRangeSpec;
-use super::storage_api::remote_s3_client::RemoteS3ClientError;
+use crate::bucket::remote_s3_client::RemoteS3ClientError;
+use crate::storage_api_contracts::range::HTTPRangeSpec;
 use hmac::{Hmac, Mac, digest::KeyInit};
 use http::{HeaderMap, HeaderValue, Method};
 use quick_xml::Reader;
@@ -549,9 +549,9 @@ fn leaf_text(reader: &mut Reader<&[u8]>, end: quick_xml::name::QName<'_>) -> Res
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::on_demand_migration::backend_contract::{BackendCapabilities, assert_backend_contract};
-    use crate::on_demand_migration::source_client::SourceError;
-    use crate::on_demand_migration::test_http_fixture::{ScriptedResponse, scripted_server};
+    use crate::bucket::on_demand_migration::backend_contract::{BackendCapabilities, assert_backend_contract};
+    use crate::bucket::on_demand_migration::source_client::SourceError;
+    use crate::bucket::on_demand_migration::test_http_fixture::{ScriptedResponse, scripted_server};
 
     const LIST_PAGE: &str = r#"<?xml version="1.0" encoding="utf-8"?>
 <EnumerationResults ServiceEndpoint="https://acct.blob.core.windows.net/" ContainerName="legacy">

crates/ecstore/src/bucket/on_demand_migration/backend_contract.rs

@@ -27,7 +27,7 @@
 //! and whether the provider can resume a listing from a key.
 
 use super::source_client::{SourceBackend, SourceError, SourceListRequest};
-use super::storage_api::HTTPRangeSpec;
+use crate::storage_api_contracts::range::HTTPRangeSpec;
 use std::collections::HashMap;
 
 /// The single object every fixture serves.

crates/ecstore/src/bucket/on_demand_migration/backfill.rs

@@ -45,12 +45,16 @@
 
 use super::pull::{EnqueueOutcome, PullReason, QueuedPullOutcome};
 use super::source_client::{SourceError, SourcePage};
-use super::storage_api::{
-    BUCKET_META_PREFIX, ECStore, HTTPPreconditions, NamespaceLocking as _, ObjectOperations as _, ObjectOptions,
-    RUSTFS_META_BUCKET, StorageError, WriteCompletion, get_lock_acquire_timeout, get_on_demand_migration_config_in,
-    local_node_name, read_config_with_metadata, save_config_with_opts,
-};
 use super::sys::{BucketOdmState, OnDemandMigrationSys};
+use crate::bucket::metadata_sys::bucket_metadata_sys_of;
+use crate::config::com::{read_config_with_metadata, save_config_with_opts};
+use crate::disk::{BUCKET_META_PREFIX, RUSTFS_META_BUCKET};
+use crate::error::Error as StorageError;
+use crate::object_api::ObjectOptions;
+use crate::runtime::sources::local_node_name;
+use crate::set_disk::get_lock_acquire_timeout;
+use crate::storage_api_contracts::{namespace::NamespaceLocking as _, object::HTTPPreconditions, object::ObjectOperations as _};
+use crate::store::ECStore;
 use async_trait::async_trait;
 use futures::StreamExt;
 use futures::stream::FuturesUnordered;
@@ -370,8 +374,6 @@ pub type PullReport = Option<super::pull::QueuedPullReport>;
 /// mock in unit tests. Production: [`BucketBackfillContext`].
 #[async_trait]
 pub trait BackfillContext: Send + Sync {
-    /// The bucket incarnation captured by this context.
-    fn incarnation_id(&self) -> Uuid;
     /// One source page in the local key namespace.
     async fn list_page(&self, prefix: Option<&str>, token: Option<&str>, max_keys: i32) -> Result<SourcePage, SourceError>;
     /// Whether the breaker admits source traffic right now.
@@ -413,10 +415,6 @@ impl BucketBackfillContext {
 
 #[async_trait]
 impl BackfillContext for BucketBackfillContext {
-    fn incarnation_id(&self) -> Uuid {
-        self.state.incarnation_id()
-    }
-
     async fn list_page(&self, prefix: Option<&str>, token: Option<&str>, max_keys: i32) -> Result<SourcePage, SourceError> {
         let client = self.state.client().map_err(|err| SourceError::Unsupported(err.to_string()))?;
         let started = Instant::now();
@@ -476,10 +474,12 @@ impl BackfillContext for BucketBackfillContext {
     }
 
     async fn config_updated_at(&self) -> Result<Option<OffsetDateTime>, StorageError> {
-        Ok(
-            super::config::decode_stored_config(get_on_demand_migration_config_in(&self.api, self.state.bucket()).await?)?
-                .map(|(_, updated_at)| updated_at),
-        )
+        let sys = bucket_metadata_sys_of(&self.api.ctx)?;
+        let guard = sys.read().await;
+        Ok(guard
+            .get_on_demand_migration_config(self.state.bucket())
+            .await?
+            .map(|(_, updated_at)| updated_at))
     }
 }
 
@@ -667,36 +667,8 @@ pub async fn read_checkpoint(api: &Arc<ECStore>, bucket: &str) -> Result<Option<
 async fn write_checkpoint(
     api: &Arc<ECStore>,
     bucket: &str,
-    incarnation_id: Uuid,
     checkpoint: &BackfillCheckpoint,
     expected_etag: Option<&str>,
-) -> Result<String, BackfillError> {
-    let api = Arc::clone(api);
-    let bucket = bucket.to_string();
-    let checkpoint = checkpoint.clone();
-    let expected_etag = expected_etag.map(str::to_string);
-    // The storage commit owns detached work. Keep its user-bucket fence alive
-    // even when a caller aborts its waiter before the erasure tail has drained.
-    tokio::spawn(async move {
-        let fence = api.acquire_bucket_incarnation_fence(&bucket, incarnation_id).await?;
-        let mut opts = ObjectOptions::default();
-        fence.attach_to_object_options(&mut opts);
-        let result = write_checkpoint_while_fenced(&api, &bucket, &checkpoint, expected_etag.as_deref(), opts).await;
-        drop(fence);
-        result
-    })
-    .await
-    .map_err(|err| StorageError::other(format!("backfill checkpoint task failed: {err}")))?
-}
-
-/// The caller holds the destination bucket's lifecycle fence through the CAS
-/// write and its read-back, including the drained erasure write tail.
-async fn write_checkpoint_while_fenced(
-    api: &Arc<ECStore>,
-    bucket: &str,
-    checkpoint: &BackfillCheckpoint,
-    expected_etag: Option<&str>,
-    mut opts: ObjectOptions,
 ) -> Result<String, BackfillError> {
     let data = checkpoint.to_json()?;
     let preconditions = match expected_etag {
@@ -709,9 +681,12 @@ async fn write_checkpoint_while_fenced(
             ..Default::default()
         },
     };
-    opts.max_parity = true;
-    opts.write_completion = WriteCompletion::TailDrained;
-    opts.http_preconditions = Some(preconditions);
+    let opts = ObjectOptions {
+        max_parity: true,
+        write_completion: crate::object_api::WriteCompletion::TailDrained,
+        http_preconditions: Some(preconditions),
+        ..Default::default()
+    };
     match save_config_with_opts(Arc::clone(api), &checkpoint_path(bucket), data, &opts).await {
         Ok(()) => {}
         Err(StorageError::PreconditionFailed) => return Err(BackfillError::Conflict(bucket.to_string())),
@@ -882,14 +857,7 @@ impl BackfillRunner {
             });
         }
         let checkpoint = BackfillCheckpoint::new(&request, config_updated_at, &self.node, now);
-        let etag = write_checkpoint(
-            &self.api,
-            bucket,
-            context.incarnation_id(),
-            &checkpoint,
-            stored.as_ref().map(|s| s.etag.as_str()),
-        )
-        .await?;
+        let etag = write_checkpoint(&self.api, bucket, &checkpoint, stored.as_ref().map(|s| s.etag.as_str())).await?;
         info!(
             event = EVENT_ODM_BACKFILL_STATE,
             component = LOG_COMPONENT_ECSTORE,
@@ -924,42 +892,30 @@ impl BackfillRunner {
             }
             return Ok(handle.snapshot.lock().clone());
         }
-        let incarnation_id = self.api.bucket_incarnation_id_from_disk(bucket).await?;
-        let lock = self.lease_lock(bucket, get_lock_acquire_timeout()).await?;
-        let api = Arc::clone(&self.api);
-        let bucket = bucket.to_string();
-        tokio::spawn(async move {
-            let _lock = lock;
-            let fence = api.acquire_bucket_incarnation_fence(&bucket, incarnation_id).await?;
-            let mut opts = ObjectOptions::default();
-            fence.attach_to_object_options(&mut opts);
-            let Some(stored) = read_checkpoint(&api, &bucket).await? else {
-                return Err(BackfillError::NotFound(bucket.to_string()));
-            };
-            if !stored.checkpoint.state.is_active() {
-                return Ok(stored.checkpoint);
-            }
-            let mut checkpoint = stored.checkpoint;
-            let now = OffsetDateTime::now_utc();
-            checkpoint.state = BackfillState::Cancelled;
-            checkpoint.updated_at = now;
-            write_checkpoint_while_fenced(&api, &bucket, &checkpoint, Some(&stored.etag), opts).await?;
-            info!(
-                event = EVENT_ODM_BACKFILL_STATE,
-                component = LOG_COMPONENT_ECSTORE,
-                subsystem = LOG_SUBSYSTEM_ON_DEMAND_MIGRATION,
-                state = checkpoint.state.as_str(),
-                result = "cancelled",
-                bucket = %bucket,
-                job_id = %checkpoint.job_id,
-                owner = %checkpoint.owner.as_ref().map(|o| o.node.as_str()).unwrap_or_default(),
-                "On-demand migration backfill job cancelled remotely"
-            );
-            drop(fence);
-            Ok(checkpoint)
-        })
-        .await
-        .map_err(|err| StorageError::other(format!("backfill cancellation task failed: {err}")))?
+        let _lock = self.lease_lock(bucket, get_lock_acquire_timeout()).await?;
+        let Some(stored) = read_checkpoint(&self.api, bucket).await? else {
+            return Err(BackfillError::NotFound(bucket.to_string()));
+        };
+        if !stored.checkpoint.state.is_active() {
+            return Ok(stored.checkpoint);
+        }
+        let mut checkpoint = stored.checkpoint;
+        let now = OffsetDateTime::now_utc();
+        checkpoint.state = BackfillState::Cancelled;
+        checkpoint.updated_at = now;
+        write_checkpoint(&self.api, bucket, &checkpoint, Some(&stored.etag)).await?;
+        info!(
+            event = EVENT_ODM_BACKFILL_STATE,
+            component = LOG_COMPONENT_ECSTORE,
+            subsystem = LOG_SUBSYSTEM_ON_DEMAND_MIGRATION,
+            state = checkpoint.state.as_str(),
+            result = "cancelled",
+            bucket = %bucket,
+            job_id = %checkpoint.job_id,
+            owner = %checkpoint.owner.as_ref().map(|o| o.node.as_str()).unwrap_or_default(),
+            "On-demand migration backfill job cancelled remotely"
+        );
+        Ok(checkpoint)
     }
 
     /// Latest checkpoint: the in-memory progress of a local job, else the
@@ -1052,7 +1008,7 @@ impl BackfillRunner {
             checkpoint.state = BackfillState::Cancelled;
             checkpoint.updated_at = now;
             checkpoint.record_failure("config_changed", None, now);
-            write_checkpoint(&self.api, bucket, context.incarnation_id(), &checkpoint, Some(&stored.etag)).await?;
+            write_checkpoint(&self.api, bucket, &checkpoint, Some(&stored.etag)).await?;
             info!(
                 event = EVENT_ODM_BACKFILL_STATE,
                 component = LOG_COMPONENT_ECSTORE,
@@ -1071,7 +1027,7 @@ impl BackfillRunner {
             node: self.node.clone(),
             lease_until: now + BACKFILL_LEASE,
         });
-        let etag = write_checkpoint(&self.api, bucket, context.incarnation_id(), &checkpoint, Some(&stored.etag)).await?;
+        let etag = write_checkpoint(&self.api, bucket, &checkpoint, Some(&stored.etag)).await?;
         warn!(
             event = EVENT_ODM_BACKFILL_LEASE_TAKEOVER,
             component = LOG_COMPONENT_ECSTORE,
@@ -1510,8 +1466,7 @@ impl Job {
                 lease_until: now + BACKFILL_LEASE,
             });
         }
-        let etag =
-            write_checkpoint(&self.api, &self.bucket, self.context.incarnation_id(), &self.checkpoint, Some(&self.etag)).await?;
+        let etag = write_checkpoint(&self.api, &self.bucket, &self.checkpoint, Some(&self.etag)).await?;
         self.etag = etag;
         self.keys_since_save = 0;
         self.last_save = Instant::now();
@@ -1523,7 +1478,7 @@ impl Job {
 /// Spawns [`run_backfill_recovery_loop`] on the store's shutdown token;
 /// `false` (nothing spawned) when the store has no background token.
 pub fn spawn_backfill_recovery_loop(runner: Arc<BackfillRunner>) -> bool {
-    let Some(cancel) = runner.api.background_cancel_token() else {
+    let Some(cancel) = runner.api.ctx.background_cancel_token() else {
         return false;
     };
     tokio::spawn(run_backfill_recovery_loop(runner, cancel));
@@ -1551,13 +1506,10 @@ pub async fn run_backfill_recovery_loop(runner: Arc<BackfillRunner>, cancel: Can
 
 #[cfg(test)]
 mod tests {
-    use super::super::storage_api::test_support::{
-        BUCKET_LIFECYCLE_LOCK_OBJECT, BucketOperations as _, PutObjectCommitBarrier, PutObjectCommitPause,
-        isolated_store_over_temp_disks,
-    };
     use super::*;
-    use crate::on_demand_migration::source_client::SourceObject;
-    use crate::on_demand_migration::sys::PullError;
+    use crate::bucket::metadata_sys::test_support::isolated_store_over_temp_disks;
+    use crate::bucket::on_demand_migration::source_client::SourceObject;
+    use crate::bucket::on_demand_migration::sys::PullError;
     use std::collections::{BTreeSet, HashSet};
     use std::sync::atomic::AtomicBool;
 
@@ -1680,7 +1632,6 @@ mod tests {
 
     /// Scripted source + local store + queue with a controllable report path.
     struct MockContext {
-        incarnation_id: Mutex<Option<Uuid>>,
         objects: Vec<SourceObject>,
         page_size: usize,
         local: Mutex<HashMap<String, LocalBackfillObject>>,
@@ -1709,7 +1660,6 @@ mod tests {
                 })
                 .collect();
             Arc::new(Self {
-                incarnation_id: Mutex::new(None),
                 objects,
                 page_size,
                 local: Mutex::new(HashMap::new()),
@@ -1744,10 +1694,6 @@ mod tests {
 
     #[async_trait]
     impl BackfillContext for MockContext {
-        fn incarnation_id(&self) -> Uuid {
-            self.incarnation_id.lock().expect("test bucket initialized")
-        }
-
         async fn list_page(&self, prefix: Option<&str>, token: Option<&str>, max_keys: i32) -> Result<SourcePage, SourceError> {
             if let Some(err) = self.list_error.lock().take() {
                 return Err(err);
@@ -1840,17 +1786,12 @@ mod tests {
         context: Arc<MockContext>,
     ) -> (Vec<tempfile::TempDir>, Arc<ECStore>, Arc<BackfillRunner>) {
         let (dirs, store) = isolated_store_over_temp_disks().await;
-        super::super::storage_api::test_support::init_bucket_metadata_sys(Arc::clone(&store), Vec::new()).await;
-        store
-            .make_bucket(bucket, &Default::default())
-            .await
-            .expect("create test bucket");
-        *context.incarnation_id.lock() = Some(
-            store
-                .bucket_incarnation_id_from_disk(bucket)
-                .await
-                .expect("test bucket identity"),
-        );
+        // The isolated store has no bucket metadata system; the checkpoint
+        // only needs the bucket's directory under the metadata volume.
+        for dir in &dirs {
+            std::fs::create_dir_all(dir.path().join(RUSTFS_META_BUCKET).join(BUCKET_META_PREFIX).join(bucket))
+                .expect("test bucket metadata directory");
+        }
         let runner = runner_on(node, bucket, context, Arc::clone(&store));
         (dirs, store, runner)
     }
@@ -1860,129 +1801,6 @@ mod tests {
         BackfillRunner::new(store, node, Arc::new(contexts))
     }
 
-    #[tokio::test]
-    async fn cancelled_checkpoint_waiter_keeps_bucket_fenced_until_commit_finishes() {
-        for (suffix, pause) in [
-            ("before", PutObjectCommitPause::BeforeQuotaRename),
-            ("after", PutObjectCommitPause::AfterRenameQuorum),
-        ] {
-            let bucket = format!("backfill-cancel-tail-{suffix}");
-            let context = MockContext::new(0, 1);
-            let (_dirs, store, _runner) = runner_with("node-a", &bucket, Arc::clone(&context)).await;
-            let original_incarnation = context.incarnation_id();
-            let checkpoint = BackfillCheckpoint::new(&BackfillRequest::default(), ts(1_700_000_000), "node-a", ts(1_700_000_001));
-            let barrier = PutObjectCommitBarrier::install(RUSTFS_META_BUCKET, &checkpoint_path(&bucket), pause);
-            let writer_api = Arc::clone(&store);
-            let writer_bucket = bucket.clone();
-            let waiter = tokio::spawn(async move {
-                write_checkpoint(&writer_api, &writer_bucket, original_incarnation, &checkpoint, None).await
-            });
-            barrier.wait_until_paused().await;
-            waiter.abort();
-            assert!(waiter.await.expect_err("caller aborted").is_cancelled());
-
-            let lifecycle_lock = store
-                .new_ns_lock(&bucket, BUCKET_LIFECYCLE_LOCK_OBJECT)
-                .await
-                .expect("lifecycle lock");
-            {
-                let mut probe = Box::pin(lifecycle_lock.get_write_lock(Duration::from_secs(1)));
-                assert!(
-                    futures::poll!(probe.as_mut()).is_pending(),
-                    "lifecycle writer must first try to acquire the lock"
-                );
-                assert!(
-                    tokio::time::timeout(Duration::from_millis(100), probe.as_mut())
-                        .await
-                        .is_err(),
-                    "the checkpoint owner must retain the user bucket lifecycle read lock after caller cancellation"
-                );
-            }
-
-            let delete_api = Arc::clone(&store);
-            let delete_bucket = bucket.clone();
-            let mut deletion = tokio::spawn(async move { delete_api.delete_bucket(&delete_bucket, &Default::default()).await });
-            assert!(
-                tokio::time::timeout(Duration::from_millis(100), &mut deletion).await.is_err(),
-                "DeleteBucket must wait for the checkpoint owner after its caller aborts"
-            );
-            barrier.release();
-            tokio::time::timeout(Duration::from_secs(10), deletion)
-                .await
-                .expect("commit must drain and release its lifecycle guard")
-                .expect("delete task")
-                .expect("delete original bucket");
-            store
-                .make_bucket(&bucket, &Default::default())
-                .await
-                .expect("recreate bucket");
-            assert_ne!(
-                original_incarnation,
-                store.bucket_incarnation_id_from_disk(&bucket).await.expect("new identity")
-            );
-            assert!(
-                read_checkpoint(&store, &bucket)
-                    .await
-                    .expect("read recreated bucket")
-                    .is_none(),
-                "no old checkpoint may outlive bucket deletion"
-            );
-        }
-    }
-
-    #[tokio::test]
-    async fn stale_checkpoint_writer_cannot_resurrect_or_overwrite_a_recreated_bucket() {
-        let bucket = "backfill-incarnation";
-        let context = MockContext::new(0, 1);
-        let (_dirs, store, _runner) = runner_with("node-a", bucket, Arc::clone(&context)).await;
-        let old_incarnation = context.incarnation_id();
-        let old = BackfillCheckpoint::new(&BackfillRequest::default(), ts(1_700_000_000), "node-a", ts(1_700_000_001));
-        let old_etag = write_checkpoint(&store, bucket, old_incarnation, &old, None)
-            .await
-            .expect("old checkpoint");
-
-        store
-            .delete_bucket(bucket, &Default::default())
-            .await
-            .expect("delete original bucket");
-        store.make_bucket(bucket, &Default::default()).await.expect("recreate bucket");
-        let current_incarnation = store.bucket_incarnation_id_from_disk(bucket).await.expect("new identity");
-        assert_ne!(old_incarnation, current_incarnation);
-        assert!(
-            read_checkpoint(&store, bucket)
-                .await
-                .expect("read after recreation")
-                .is_none()
-        );
-        for expected_etag in [None, Some(old_etag.as_str())] {
-            let error = write_checkpoint(&store, bucket, old_incarnation, &old, expected_etag)
-                .await
-                .expect_err("stale writer rejected");
-            assert!(matches!(error, BackfillError::Storage(StorageError::BucketNotFound(_))));
-        }
-        assert!(
-            read_checkpoint(&store, bucket)
-                .await
-                .expect("stale writer left no checkpoint")
-                .is_none()
-        );
-
-        let current = BackfillCheckpoint::new(&BackfillRequest::default(), ts(1_700_000_000), "node-b", ts(1_700_000_002));
-        let current_etag = write_checkpoint(&store, bucket, current_incarnation, &current, None)
-            .await
-            .expect("current checkpoint");
-        let error = write_checkpoint(&store, bucket, old_incarnation, &old, Some(&current_etag))
-            .await
-            .expect_err("old identity cannot overwrite a matching ETag");
-        assert!(matches!(error, BackfillError::Storage(StorageError::BucketNotFound(_))));
-        let stored = read_checkpoint(&store, bucket)
-            .await
-            .expect("read current checkpoint")
-            .expect("current checkpoint remains");
-        assert_eq!(stored.etag, current_etag);
-        assert_eq!(stored.checkpoint, current);
-    }
-
     #[tokio::test]
     async fn full_backfill_lists_pages_and_counts_every_key() {
         let bucket = "backfill-full";
@@ -2322,7 +2140,7 @@ mod tests {
             node: "node-a".to_string(),
             lease_until: now - Duration::from_secs(120),
         });
-        let etag = write_checkpoint(&store, bucket, context.incarnation_id(), &crashed, None)
+        let etag = write_checkpoint(&store, bucket, &crashed, None)
             .await
             .expect("seed checkpoint");
 
@@ -2333,7 +2151,7 @@ mod tests {
             lease_until: now + Duration::from_secs(60),
         });
         live.updated_at = now;
-        let etag = write_checkpoint(&store, bucket, context.incarnation_id(), &live, Some(&etag))
+        let etag = write_checkpoint(&store, bucket, &live, Some(&etag))
             .await
             .expect("live lease");
         assert_eq!(runner.recover_once().await.taken_over, 0, "unexpired lease must not be taken over");
@@ -2350,7 +2168,7 @@ mod tests {
             lease_until: now - Duration::from_secs(1),
         });
         expired.updated_at = now + Duration::from_millis(1);
-        write_checkpoint(&store, bucket, context.incarnation_id(), &expired, Some(&etag))
+        write_checkpoint(&store, bucket, &expired, Some(&etag))
             .await
             .expect("expire lease");
         let stats = runner.recover_once().await;
@@ -2389,7 +2207,7 @@ mod tests {
         crashed.continuation_token = Some("2".to_string());
         crashed.failed = 1;
         crashed.record_failure("local_write", Some("k/00002"), crashed_at);
-        write_checkpoint(&store, bucket, context.incarnation_id(), &crashed, None)
+        write_checkpoint(&store, bucket, &crashed, None)
             .await
             .expect("seed failed page with an expired lease");
 
@@ -2445,9 +2263,7 @@ mod tests {
 
         // Same node name, unexpired lease: only a restart can produce this.
         let own = BackfillCheckpoint::new(&BackfillRequest::default(), ts(1_700_000_000), "node-a", now);
-        let etag = write_checkpoint(&store, bucket, context.incarnation_id(), &own, None)
-            .await
-            .expect("seed");
+        let etag = write_checkpoint(&store, bucket, &own, None).await.expect("seed");
         assert_eq!(runner.recover_once().await.taken_over, 1, "own-node running job is reclaimed at once");
         runner.wait_until_idle(bucket).await;
         let cp = read_checkpoint(&store, bucket)
@@ -2465,7 +2281,7 @@ mod tests {
             node: "node-z".to_string(),
             lease_until: now - Duration::from_secs(1),
         });
-        write_checkpoint(&store, bucket, context.incarnation_id(), &stale, Some(&stored.etag))
+        write_checkpoint(&store, bucket, &stale, Some(&stored.etag))
             .await
             .expect("seed stale");
         let stats = runner.recover_once().await;

crates/ecstore/src/bucket/on_demand_migration/config.rs

@@ -14,34 +14,16 @@
 
 //! Bucket-level On-Demand Migration configuration: wire model (JSON stored
 //! under `on-demand-migration.json`), pure validation, credential redaction,
-//! and persisted-config decoding (rustfs/backlog#2148).
+//! and the publish hook the runtime registers into (rustfs/backlog#2148).
 //!
 //! The persisted blob is not encrypted; it shares the trust boundary of
 //! `bucket-targets.json` and `tier-config.bin`.
 
 use serde::{Deserialize, Serialize};
 use std::fmt;
+use std::sync::OnceLock;
 use url::Url;
 
-/// Decode bytes only at the service boundary, preserving typed corruption errors.
-pub(super) fn decode_stored_config(
-    stored: Option<(Vec<u8>, time::OffsetDateTime)>,
-) -> Result<Option<(OnDemandMigrationConfig, time::OffsetDateTime)>, super::storage_api::StorageError> {
-    stored
-        .map(|(bytes, updated_at)| {
-            OnDemandMigrationConfig::from_json(&bytes)
-                .map(|config| (config, updated_at))
-                .map_err(super::storage_api::StorageError::other)
-        })
-        .transpose()
-}
-
-pub(crate) async fn get_config(
-    bucket: &str,
-) -> Result<Option<(OnDemandMigrationConfig, time::OffsetDateTime)>, super::storage_api::StorageError> {
-    decode_stored_config(super::storage_api::get_on_demand_migration_config(bucket).await?)
-}
-
 /// The only wire version this build reads and writes.
 pub const ON_DEMAND_MIGRATION_CONFIG_VERSION: u32 = 1;
 
@@ -804,6 +786,16 @@ impl EndpointKey {
     }
 }
 
+/// Signature of the runtime publish hook: called with the bucket name and
+/// its parsed config (`None` when absent, cleared, or unreadable) every time
+/// the bucket's metadata is installed into or removed from the cache.
+pub type ConfigPublishHook = Box<dyn Fn(&str, Option<&OnDemandMigrationConfig>) + Send + Sync>;
+
+/// Registration point for the runtime (`OnDemandMigrationSys`). Until it is
+/// set, metadata publishes are no-ops for ODM, so this crate carries no
+/// runtime dependency and the config layer stays inert.
+pub static ON_DEMAND_MIGRATION_CONFIG_HOOK: OnceLock<ConfigPublishHook> = OnceLock::new();
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1509,55 +1501,4 @@ mod tests {
         assert!(!rendered.contains("topsecret"), "{rendered}");
         assert!(!rendered.contains("SK"), "{rendered}");
     }
-    /// rustfs/backlog#2148: the accessor reports absence as `Ok(None)` and a
-    /// stored payload it cannot parse as a typed error, never as a default
-    /// and never as `ConfigNotFound`.
-    #[tokio::test]
-    async fn get_on_demand_migration_config_distinguishes_absent_from_corrupt() {
-        use super::super::storage_api::StorageError as Error;
-        use super::super::storage_api::test_support::{
-            BUCKET_ON_DEMAND_MIGRATION_CONFIG, BucketMetadata, BucketMetadataSys, isolated_store_over_temp_disks,
-        };
-        use std::sync::Arc;
-        const ODM_JSON: &[u8] = br#"{"source":{"provider":"minio","endpoint":"https://legacy.example.com:9000","region":"auto","bucket":"legacy-bucket","credentials":{"access_key":"AK","secret_key":"SK"}}}"#;
-
-        let (_dirs, ecstore) = isolated_store_over_temp_disks().await;
-        let sys = BucketMetadataSys::new(ecstore);
-        let bucket = "odm-accessor";
-
-        sys.set(bucket.to_string(), Arc::new(BucketMetadata::new(bucket))).await;
-        assert_eq!(
-            decode_stored_config(sys.get_on_demand_migration_config(bucket).await.unwrap()).unwrap(),
-            None
-        );
-
-        let mut corrupt = BucketMetadata::new(bucket);
-        corrupt.on_demand_migration_config_json = br#"{"source":{"provider":"s3"},"bogus":1}"#.to_vec();
-        sys.set(bucket.to_string(), Arc::new(corrupt)).await;
-        let err = decode_stored_config(sys.get_on_demand_migration_config(bucket).await.unwrap())
-            .expect_err("corrupt config must not read as a default");
-        assert_ne!(err, Error::ConfigNotFound, "corruption must not be reported as absence");
-        let typed = match &err {
-            Error::Io(io) => io
-                .get_ref()
-                .and_then(|source| source.downcast_ref::<OnDemandMigrationConfigError>()),
-            _ => None,
-        };
-        assert!(
-            matches!(typed, Some(OnDemandMigrationConfigError::Malformed(_))),
-            "typed parse error must survive the Result boundary, got: {err:?}"
-        );
-
-        let mut valid = BucketMetadata::new(bucket);
-        valid
-            .update_config(BUCKET_ON_DEMAND_MIGRATION_CONFIG, ODM_JSON.to_vec())
-            .unwrap();
-        let stamped = valid.on_demand_migration_config_updated_at;
-        sys.set(bucket.to_string(), Arc::new(valid)).await;
-        let (config, updated_at) = decode_stored_config(sys.get_on_demand_migration_config(bucket).await.unwrap())
-            .unwrap()
-            .expect("stored config is returned");
-        assert_eq!(config, OnDemandMigrationConfig::from_json(ODM_JSON).unwrap());
-        assert_eq!(updated_at, stamped);
-    }
 }

crates/ecstore/src/bucket/on_demand_migration/gcs.rs

@@ -43,8 +43,8 @@ use super::source_client::{
     GcsSourceSpec, SourceBackend, SourceError, SourceGet, SourceHead, SourceListRequest, SourceObject, SourcePage,
     SourceTimeouts, range_header_value,
 };
-use super::storage_api::HTTPRangeSpec;
-use super::storage_api::remote_s3_client::RemoteS3ClientError;
+use crate::bucket::remote_s3_client::RemoteS3ClientError;
+use crate::storage_api_contracts::range::HTTPRangeSpec;
 use google_cloud_auth::credentials::service_account::{AccessSpecifier, Builder as ServiceAccountBuilder};
 use google_cloud_auth::credentials::{CacheableResource, Credentials};
 use http::{HeaderMap, HeaderValue, Method};
@@ -124,18 +124,6 @@ impl GcsNativeSourceBackend {
         Ok(request)
     }
 
-    async fn send_object(&self, request: reqwest::Request) -> Result<reqwest::Response, SourceError> {
-        match self.http.send_object(request, NO_ERROR_CODE_HEADER).await {
-            Err(SourceError::NotFound) => {
-                // An XML object URL also returns 404 when its bucket is gone.
-                // Reuse the read-only listing probe before caching a key miss.
-                self.probe().await?;
-                Err(SourceError::NotFound)
-            }
-            result => result,
-        }
-    }
-
     /// Shared mapping for the XML API's HEAD and GET responses.
     fn head_from_response(headers: &HeaderMap) -> Result<SourceHead, SourceError> {
         if header(headers, "x-goog-encryption-key-sha256").is_some() {
@@ -176,7 +164,7 @@ impl GcsNativeSourceBackend {
 impl SourceBackend for GcsNativeSourceBackend {
     async fn head(&self, key: &str) -> Result<SourceHead, SourceError> {
         let request = self.request(Method::HEAD, self.object_url(key)?, HeaderMap::new()).await?;
-        let response = self.send_object(request).await?;
+        let response = self.http.send(request, NO_ERROR_CODE_HEADER).await?;
         Self::head_from_response(response.headers())
     }
 
@@ -189,7 +177,7 @@ impl SourceBackend for GcsNativeSourceBackend {
             );
         }
         let request = self.request(Method::GET, self.object_url(key)?, headers).await?;
-        let response = self.send_object(request).await?;
+        let response = self.http.send(request, NO_ERROR_CODE_HEADER).await?;
         let head = Self::head_from_response(response.headers())?;
         let content_range = header(response.headers(), "content-range").map(str::to_string);
         Ok(SourceGet {
@@ -318,8 +306,8 @@ fn parse_objects_list(body: &str) -> Result<SourcePage, SourceError> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::on_demand_migration::backend_contract::{BackendCapabilities, assert_backend_contract};
-    use crate::on_demand_migration::test_http_fixture::{ScriptedResponse, scripted_server};
+    use crate::bucket::on_demand_migration::backend_contract::{BackendCapabilities, assert_backend_contract};
+    use crate::bucket::on_demand_migration::test_http_fixture::{ScriptedResponse, scripted_server};
     use google_cloud_auth::credentials::anonymous::Builder as AnonymousBuilder;
 
     const LIST_PAGE_ONE: &str = r#"{
@@ -500,7 +488,6 @@ mod tests {
             // request; the probe is the next one on the wire.
             ScriptedResponse::new(200, Vec::new(), "{}".to_string()),
             ScriptedResponse::new(404, Vec::new(), String::new()),
-            ScriptedResponse::new(200, Vec::new(), "{}".to_string()),
             ScriptedResponse::new(403, Vec::new(), String::new()),
         ])
         .await;
@@ -516,49 +503,4 @@ mod tests {
         )
         .await;
     }
-
-    #[tokio::test]
-    async fn listing_404_is_not_an_object_not_found() {
-        let (endpoint, _) = scripted_server(vec![ScriptedResponse::new(404, Vec::new(), String::new())]).await;
-        let err = backend(&endpoint)
-            .list(&SourceListRequest {
-                max_keys: 1,
-                ..Default::default()
-            })
-            .await
-            .expect_err("a failed bucket listing is not a per-object miss");
-        assert_eq!(err.class_label(), "other", "{err:?}");
-    }
-
-    #[tokio::test]
-    async fn object_404_requires_a_readable_source_bucket() {
-        for method in [Method::HEAD, Method::GET] {
-            for (probe_status, expected_class) in [
-                (200, "not_found"),
-                (404, "other"),
-                (403, "access_denied"),
-                (503, "throttled"),
-                (500, "server_error"),
-            ] {
-                let (endpoint, recorded) = scripted_server(vec![
-                    ScriptedResponse::new(404, Vec::new(), String::new()),
-                    ScriptedResponse::new(probe_status, Vec::new(), "{}".to_string()),
-                ])
-                .await;
-                let backend = backend(&endpoint);
-                let result = if method == Method::HEAD {
-                    backend.head("missing").await.map(|_| ())
-                } else {
-                    backend.get("missing", None).await.map(|_| ())
-                };
-                let error = result.expect_err("the object 404 must remain an error");
-                assert_eq!(error.class_label(), expected_class, "{method} with probe HTTP {probe_status}: {error:?}");
-                let recorded = recorded.lock().expect("recorder lock");
-                assert_eq!(recorded.len(), 2, "one bounded read-only probe per ambiguous object miss");
-                assert_eq!(recorded[0].method, method.as_str());
-                assert_eq!(recorded[1].method, "GET");
-                assert_eq!(recorded[1].target, "/storage/v1/b/legacy/o?maxResults=1");
-            }
-        }
-    }
 }

crates/ecstore/src/bucket/on_demand_migration/list_through.rs

@@ -1089,17 +1089,10 @@ mod tests {
 
     #[test]
     fn progress_tokens_preserve_v1_bytes_and_validate_v2_counts() {
-        fn framed(payload: &str) -> String {
-            format!("{LIST_THROUGH_TOKEN_PREFIX}{payload}")
-        }
-
         let token = progress_token(None, true, false);
         assert_eq!(
             token.encode(),
-            concat!(
-                "\0odm-list:",
-                r#"{"t":"odm-list","v":1,"local":null,"local_done":true,"source":"A","source_done":false,"last_key":"last-key"}"#
-            )
+            r#"{"t":"odm-list","v":1,"local":null,"local_done":true,"source":"A","source_done":false,"last_key":"last-key"}"#
         );
         for count in 1..MAX_LIST_NO_PROGRESS_PAGES {
             let token = progress_token(Some(count), true, false);
@@ -1107,17 +1100,16 @@ mod tests {
         }
         for version in [1, 2] {
             for value in ["null", "0", "16", "-1", "1.5", "256", "18446744073709551616", "\"1\""] {
-                let encoded = framed(&format!(r#"{{"t":"odm-list","v":{version},"no_progress":{value}}}"#));
+                let encoded = format!(r#"{{"t":"odm-list","v":{version},"no_progress":{value}}}"#);
                 assert_eq!(decode_continuation_token(&encoded), Err(ListThroughTokenError::Malformed), "{encoded}");
             }
         }
-        for payload in [
+        for encoded in [
             r#"{"t":"odm-list","v":1,"no_progress":1}"#,
             r#"{"t":"odm-list","v":2}"#,
             r#"{"t":"odm-list","v":2,"no_progress":1,"extra":true}"#,
         ] {
-            let encoded = framed(payload);
-            assert_eq!(decode_continuation_token(&encoded), Err(ListThroughTokenError::Malformed), "{encoded}");
+            assert_eq!(decode_continuation_token(encoded), Err(ListThroughTokenError::Malformed), "{encoded}");
         }
     }
 

crates/ecstore/src/bucket/on_demand_migration/mod.rs

@@ -30,16 +30,13 @@ mod backend_contract;
 pub mod backfill;
 pub mod breaker;
 pub mod config;
-#[cfg(feature = "gcs")]
 pub mod gcs;
 pub mod list_through;
-mod metrics;
 mod native_http;
 pub mod negative_cache;
 pub mod pull;
 pub mod source_client;
 pub mod stats;
-mod storage_api;
 pub mod sys;
 #[cfg(test)]
 mod test_http_fixture;
@@ -49,9 +46,9 @@ pub use breaker::{
     BreakerState, BreakerTransition, BreakerVerdict,
 };
 pub use config::{
-    AzureSourceConfig, FilterConfig, GcsSourceConfig, HeadPolicy, ON_DEMAND_MIGRATION_CONFIG_VERSION, OnDemandMigrationConfig,
-    OnDemandMigrationConfigError, PathStyle, PolicyConfig, Provider, RangeGetPolicy, SourceConfig, SourceCredentials,
-    SourceErrorPolicy, SourceTimeout, TlsConfig, ValidationContext,
+    AzureSourceConfig, ConfigPublishHook, FilterConfig, GcsSourceConfig, HeadPolicy, ON_DEMAND_MIGRATION_CONFIG_HOOK,
+    ON_DEMAND_MIGRATION_CONFIG_VERSION, OnDemandMigrationConfig, OnDemandMigrationConfigError, PathStyle, PolicyConfig, Provider,
+    RangeGetPolicy, SourceConfig, SourceCredentials, SourceErrorPolicy, SourceTimeout, TlsConfig, ValidationContext,
 };
 pub use list_through::{
     FetchRequest, LIST_THROUGH_TOKEN_VERSION, ListEntryKey, ListPageError, ListThroughCursor, ListThroughMerger,
@@ -65,9 +62,6 @@ pub use pull::{
     PullQueue, PullReason, PullSource, QueuedPullOutcome, SourceBody, SourceIdleGuard, WriteBackBody, WriteBackError,
     WriteBackOutcome, WriteBackPart, WriteBackRequest, commit_inline, commit_inline_with, idle_guarded_body,
 };
-pub use source_client::{
-    SourceClient, SourceError, SourceGet, SourceHead, SourceListRequest, SourceObject, SourcePage, SourceSse, is_multipart_etag,
-};
 pub use stats::{
     GaugeGuard, LastSourceError, LatencyBucketSnapshot, OdmOp, OdmOutcome, OdmStats, OdmStatsSnapshot, PullFailureReason,
     PullPath, SOURCE_LATENCY_BUCKET_BOUNDS_MS, SourceLatencySnapshot,
@@ -77,7 +71,3 @@ pub use sys::{
     OnDemandMigrationSys, PullError, PullFollower, PullLeader, PullOutcome, PullResult, PullSlot, source_backend_spec,
     source_client_spec,
 };
-
-pub(crate) fn register_metrics() {
-    metrics::register();
-}

crates/ecstore/src/bucket/on_demand_migration/native_http.rs

@@ -26,7 +26,7 @@
 //! the log line and the admin response.
 
 use super::source_client::{SourceError, SourceHead, SourceTimeouts, USER_AGENT_SUFFIX, classify_status, is_multipart_etag};
-use super::storage_api::remote_s3_client::{RemoteS3ClientError, validate_remote_endpoint, validate_target_ca_pem};
+use crate::bucket::remote_s3_client::{RemoteS3ClientError, validate_remote_endpoint, validate_target_ca_pem};
 use aws_sdk_s3::primitives::ByteStream;
 use aws_smithy_types::body::SdkBody;
 use futures::StreamExt;
@@ -129,24 +129,6 @@ impl NativeHttp {
         &self,
         request: reqwest::Request,
         error_code_header: &str,
-    ) -> Result<reqwest::Response, SourceError> {
-        self.send_classified(request, error_code_header, false).await
-    }
-
-    #[cfg(feature = "gcs")]
-    pub(super) async fn send_object(
-        &self,
-        request: reqwest::Request,
-        error_code_header: &str,
-    ) -> Result<reqwest::Response, SourceError> {
-        self.send_classified(request, error_code_header, true).await
-    }
-
-    async fn send_classified(
-        &self,
-        request: reqwest::Request,
-        error_code_header: &str,
-        not_found_on_404_without_code: bool,
     ) -> Result<reqwest::Response, SourceError> {
         let response = self.client.execute(request).await.map_err(classify_transport_error)?;
         let status = response.status();
@@ -158,14 +140,14 @@ impl NativeHttp {
             .get(error_code_header)
             .and_then(|value| value.to_str().ok())
             .map(str::to_string);
-        let message = match &code {
-            Some(code) => format!("source returned HTTP {status} ({code})"),
-            None => format!("source returned HTTP {status}"),
-        };
-        match classify_status(status.as_u16(), code.as_deref(), message) {
-            SourceError::Other(_) if not_found_on_404_without_code && status.as_u16() == 404 => Err(SourceError::NotFound),
-            err => Err(err),
-        }
+        Err(classify_status(
+            status.as_u16(),
+            None,
+            match &code {
+                Some(code) => format!("source returned HTTP {status} ({code})"),
+                None => format!("source returned HTTP {status}"),
+            },
+        ))
     }
 }
 
@@ -211,7 +193,6 @@ pub(super) async fn read_text(response: reqwest::Response, max_bytes: usize) ->
 /// Base64 digest (`Content-MD5`, `md5Hash`, `x-goog-hash`) as lowercase hex.
 /// `None` when the value is not a 16-byte digest, so a CRC32C never passes as
 /// an MD5.
-#[cfg(any(test, feature = "gcs"))]
 pub(super) fn base64_md5_to_hex(value: &str) -> Option<String> {
     let raw = base64_simd::STANDARD.decode_to_vec(value.trim().as_bytes()).ok()?;
     (raw.len() == 16).then(|| faster_hex::hex_string(&raw))

crates/ecstore/src/bucket/on_demand_migration/pull.rs

@@ -243,8 +243,6 @@ impl PullSource for SourceClient {
 #[derive(Clone, Debug)]
 pub struct WriteBackRequest {
     pub bucket: String,
-    /// Identity captured with the source configuration, retained through cleanup.
-    pub bucket_incarnation_id: uuid::Uuid,
     pub key: String,
     /// Source HEAD/GET of the whole object.
     pub head: SourceHead,
@@ -265,7 +263,6 @@ impl WriteBackRequest {
         let config = state.config();
         Self {
             bucket: state.bucket().to_string(),
-            bucket_incarnation_id: state.incarnation_id(),
             key: key.to_string(),
             head,
             source_label: format!("{}:{}", config.source.provider.as_str(), config.source.bucket),
@@ -360,7 +357,7 @@ pub trait OdmWriteBack: Send + Sync {
         parts: Vec<WriteBackPart>,
     ) -> Result<WriteBackOutcome, WriteBackError>;
 
-    async fn abort_multipart_upload(&self, request: &WriteBackRequest, upload_id: &str) -> Result<(), WriteBackError>;
+    async fn abort_multipart_upload(&self, bucket: &str, key: &str, upload_id: &str) -> Result<(), WriteBackError>;
 }
 
 /// Why the pump stopped feeding the write-back before EOF.
@@ -665,7 +662,9 @@ async fn write_multipart(
         Err(err) => Err(err),
     };
     if completed.is_err()
-        && let Err(abort_err) = write_back.abort_multipart_upload(request, &upload_id).await
+        && let Err(abort_err) = write_back
+            .abort_multipart_upload(&request.bucket, &request.key, &upload_id)
+            .await
     {
         debug!(
             event = EVENT_ODM_PULL_FAILED,
@@ -1094,7 +1093,7 @@ impl OnDemandMigrationSys {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::on_demand_migration::config::{
+    use crate::bucket::on_demand_migration::config::{
         FilterConfig, OnDemandMigrationConfig, PathStyle as ConfigPathStyle, PolicyConfig, Provider, SourceConfig,
         SourceCredentials, TlsConfig,
     };
@@ -1341,7 +1340,7 @@ mod tests {
             })
         }
 
-        async fn abort_multipart_upload(&self, _request: &WriteBackRequest, upload_id: &str) -> Result<(), WriteBackError> {
+        async fn abort_multipart_upload(&self, _bucket: &str, _key: &str, upload_id: &str) -> Result<(), WriteBackError> {
             self.aborted.lock().push(upload_id.to_string());
             Ok(())
         }
@@ -1500,7 +1499,7 @@ mod tests {
         assert_eq!(failures(&state).get("queue_full"), Some(&1));
         assert!(!queue.is_stopped());
 
-        assert_eq!(sys.remove(BUCKET), crate::on_demand_migration::ApplyOutcome::Removed);
+        assert_eq!(sys.remove(BUCKET), crate::bucket::on_demand_migration::ApplyOutcome::Removed);
         tokio::time::timeout(Duration::from_secs(5), queue.wait_until_stopped())
             .await
             .expect("dispatcher and in-flight job must exit after cancel");

crates/ecstore/src/bucket/on_demand_migration/source_client.rs

@@ -26,13 +26,12 @@
 //! forwarded: v1 rejects SSE-C source objects outright.
 
 use super::azure::AzureSourceBackend;
-#[cfg(feature = "gcs")]
 use super::gcs::GcsNativeSourceBackend;
 use super::list_through::{ListPageError, validate_list_page};
-use super::storage_api::HTTPRangeSpec;
-use super::storage_api::remote_s3_client::{
+use crate::bucket::remote_s3_client::{
     PathStyle, RemoteCredentials, RemoteS3ClientError, RemoteS3EndpointSpec, RemoteS3RetryPolicy, build_remote_s3_config,
 };
+use crate::storage_api_contracts::range::HTTPRangeSpec;
 use aws_sdk_s3::Client as S3Client;
 use aws_sdk_s3::error::{ProvideErrorMetadata, SdkError};
 use aws_sdk_s3::operation::get_object::GetObjectOutput;
@@ -335,9 +334,8 @@ const THROTTLE_CODES: &[&str] = &[
     "RequestLimitExceeded",
     "TooManyRequests",
     "RequestThrottled",
-    "ServerBusy",
 ];
-const NOT_FOUND_CODES: &[&str] = &["NoSuchKey", "BlobNotFound"];
+const NOT_FOUND_CODES: &[&str] = &["NoSuchKey"];
 const ACCESS_DENIED_CODES: &[&str] = &[
     "AccessDenied",
     "InvalidAccessKeyId",
@@ -345,7 +343,6 @@ const ACCESS_DENIED_CODES: &[&str] = &[
     "AllAccessDisabled",
     "ExpiredToken",
     "InvalidToken",
-    "AuthorizationPermissionMismatch",
 ];
 
 pub(super) fn classify_status(status: u16, code: Option<&str>, message: String) -> SourceError {
@@ -723,9 +720,6 @@ impl SourceClient {
                 )?;
                 Ok(Self::from_backend(Box::new(backend), spec))
             }
-            #[cfg(not(feature = "gcs"))]
-            SourceBackendSpec::Gcs(_) => Err(RemoteS3ClientError::BackendNotCompiled("gcs_native")),
-            #[cfg(feature = "gcs")]
             SourceBackendSpec::Gcs(gcs) => {
                 let backend = GcsNativeSourceBackend::new(
                     &spec.endpoint,
@@ -995,7 +989,7 @@ fn s3_source_object(object: SdkObject) -> Result<SourceObject, SourceError> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::on_demand_migration::backend_contract::{BackendCapabilities, OBJECT_MD5, assert_backend_contract};
+    use crate::bucket::on_demand_migration::backend_contract::{BackendCapabilities, OBJECT_MD5, assert_backend_contract};
     use aws_smithy_runtime_api::client::http::{HttpConnector, HttpConnectorFuture, SharedHttpConnector, http_client_fn};
     use aws_smithy_runtime_api::client::orchestrator::HttpRequest;
     use aws_smithy_runtime_api::client::result::ConnectorError;
@@ -1117,28 +1111,6 @@ mod tests {
         }
     }
 
-    #[cfg(not(feature = "gcs"))]
-    #[tokio::test]
-    async fn gcs_backend_not_compiled_keeps_hmac_s3_available() {
-        let mut native = spec(None);
-        native.provider = SourceProvider::GcsNative;
-        native.credentials = None;
-        native.backend = SourceBackendSpec::Gcs(GcsSourceSpec {
-            service_account_json: "{}".to_string(),
-        });
-        assert!(matches!(
-            SourceClient::new(&native).await,
-            Err(RemoteS3ClientError::BackendNotCompiled("gcs_native"))
-        ));
-
-        let mut hmac = spec(None);
-        hmac.provider = SourceProvider::Gcs;
-        hmac.endpoint = "https://storage.googleapis.com".to_string();
-        SourceClient::new(&hmac)
-            .await
-            .expect("GCS HMAC uses the always-available S3 backend");
-    }
-
     async fn scripted_client(spec: &SourceClientSpec, responses: Vec<Scripted>) -> (SourceClient, Recorded) {
         let requests: Recorded = Arc::new(Mutex::new(Vec::new()));
         let connector = SharedHttpConnector::new(ScriptedConnector {
@@ -1845,7 +1817,6 @@ mod tests {
             ok(Vec::new(), CONTRACT_TAGGING),
             ok(Vec::new(), ""),
             status(404, ""),
-            ok(Vec::new(), ""),
             status(403, ACCESS_DENIED_BODY),
         ])
         .await;

crates/ecstore/src/bucket/on_demand_migration/sys.rs

@@ -19,12 +19,13 @@
 //! [`SourceClient`], a circuit breaker, a negative cache, a per-key
 //! singleflight table, a pull concurrency limit and counters. Its lifecycle
 //! follows the bucket metadata cache through the publish hook registered in
-//! [`BUCKET_CONFIG_PUBLISH_HOOK`]; the hook fires on every cache install
+//! [`ON_DEMAND_MIGRATION_CONFIG_HOOK`]; the hook fires on every cache install
 //! path (initial load, admin update, peer reload, refresh loop, lazy load).
 //!
 //! Change detection compares the config by value (`PartialEq`) rather than
-//! by `updated_at`. The bucket incarnation is part of this comparison:
-//! recreating a bucket must cancel old work even with identical configuration.
+//! by `updated_at`: the hook does not carry the timestamp, fetching it would
+//! re-enter the metadata system from inside its own publish path, and a
+//! byte-identical config never needs a new client anyway.
 //!
 //! Client construction is async (TLS material may be read from disk), so
 //! the hook does not build inline: `publish` removes state synchronously and
@@ -40,7 +41,9 @@
 
 use super::backfill::{PriorityPullPermits, PullPermit, PullPriority};
 use super::breaker::{Breaker, BreakerState, BreakerTransition, BreakerVerdict};
-use super::config::{OnDemandMigrationConfig, PathStyle as ConfigPathStyle, Provider, SourceConfig};
+use super::config::{
+    ON_DEMAND_MIGRATION_CONFIG_HOOK, OnDemandMigrationConfig, PathStyle as ConfigPathStyle, Provider, SourceConfig,
+};
 use super::list_through::{SOURCE_LIST_RATE_PER_SEC, SourceListRateLimiter};
 use super::negative_cache::NegativeCache;
 use super::pull::{OdmWriteBack, PullQueue};
@@ -49,10 +52,9 @@ use super::source_client::{
     SourceTimeouts,
 };
 use super::stats::{GaugeGuard, OdmStats, OdmStatsSnapshot, PullFailureReason};
-use super::storage_api::remote_s3_client::{
+use crate::bucket::remote_s3_client::{
     PathStyle as ClientPathStyle, RemoteCredentials, RemoteS3ClientError, RemoteS3RetryPolicy,
 };
-use super::storage_api::{BUCKET_CONFIG_PUBLISH_HOOK, BUCKET_ON_DEMAND_MIGRATION_CONFIG};
 use parking_lot::{Mutex, RwLock};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
@@ -83,8 +85,6 @@ pub static GLOBAL_ON_DEMAND_MIGRATION_SYS: OnceLock<OnDemandMigrationSys> = Once
 /// `resolve` as [`OdmLookup::Unavailable`] and through status snapshots.
 #[derive(Clone, Debug, PartialEq, Eq, thiserror::Error)]
 pub enum OdmStateError {
-    #[error("the {0} backend is not included in this build")]
-    BackendNotCompiled(&'static str),
     /// `source.credentials` is `null`; the shared client builder has no
     /// anonymous mode yet (rustfs/backlog#2149 follow-up).
     #[error("anonymous source access is not supported yet; configure source credentials")]
@@ -269,7 +269,6 @@ impl Drop for InflightEntryGuard<'_> {
 /// config change (counters excepted), removed when the config goes away.
 pub struct BucketOdmState {
     bucket: String,
-    incarnation_id: uuid::Uuid,
     config: OnDemandMigrationConfig,
     applied_at: OffsetDateTime,
     endpoint_host: String,
@@ -307,24 +306,21 @@ impl BucketOdmState {
     async fn build(
         bucket: &str,
         config: &OnDemandMigrationConfig,
-        incarnation_id: uuid::Uuid,
         stats: Arc<OdmStats>,
         write_back: Option<Arc<dyn OdmWriteBack>>,
     ) -> Arc<Self> {
         let spec = source_client_spec(config);
-        let client = if config.source.credentials.is_none() && !config.source.provider.is_native() {
+        let client = if config.source.credentials.is_none() {
             Err(OdmStateError::AnonymousUnsupported)
         } else {
             SourceClient::new(&spec).await.map(Arc::new).map_err(|err| match err {
                 RemoteS3ClientError::MissingCredentials => OdmStateError::AnonymousUnsupported,
-                RemoteS3ClientError::BackendNotCompiled(provider) => OdmStateError::BackendNotCompiled(provider),
                 other => OdmStateError::ClientBuild(other.to_string()),
             })
         };
         let policy = &config.policy;
         Arc::new(Self {
             bucket: bucket.to_string(),
-            incarnation_id,
             endpoint_host: endpoint_host(&config.source),
             config: config.clone(),
             applied_at: OffsetDateTime::now_utc(),
@@ -342,18 +338,10 @@ impl BucketOdmState {
         })
     }
 
-    pub fn filter_incarnation(self: Arc<Self>, incarnation_id: uuid::Uuid) -> Option<Arc<Self>> {
-        (self.incarnation_id == incarnation_id && !self.is_cancelled()).then_some(self)
-    }
-
     pub fn bucket(&self) -> &str {
         &self.bucket
     }
 
-    pub fn incarnation_id(&self) -> uuid::Uuid {
-        self.incarnation_id
-    }
-
     pub fn config(&self) -> &OnDemandMigrationConfig {
         &self.config
     }
@@ -749,51 +737,21 @@ impl OnDemandMigrationSys {
     /// Registers `publish` as the bucket-metadata publish hook. Returns
     /// `false` when a hook was already registered.
     pub fn register_config_hook(&'static self) -> bool {
-        BUCKET_CONFIG_PUBLISH_HOOK
-            .set(Box::new(move |bucket, config_file, stored| {
-                if config_file == BUCKET_ON_DEMAND_MIGRATION_CONFIG {
-                    self.publish_stored(bucket, stored.map(|(bytes, _, incarnation)| (bytes, incarnation)));
-                }
-            }))
+        ON_DEMAND_MIGRATION_CONFIG_HOOK
+            .set(Box::new(move |bucket, config| self.publish(bucket, config)))
             .is_ok()
     }
 
-    /// Corrupt persisted bytes withdraw state synchronously, just like deletion.
-    fn publish_stored(&'static self, bucket: &str, stored: Option<(&[u8], uuid::Uuid)>) {
-        let incarnation_id = stored.map(|(_, id)| id).unwrap_or_default();
-        match stored.map(|(bytes, _)| OnDemandMigrationConfig::from_json(bytes)).transpose() {
-            Ok(config) => self.publish_for_incarnation(bucket, incarnation_id, config.as_ref()),
-            Err(err) => {
-                warn!(
-                    event = EVENT_ODM_BUCKET_STATE_APPLIED,
-                    component = LOG_COMPONENT_ECSTORE,
-                    subsystem = LOG_SUBSYSTEM_ON_DEMAND_MIGRATION,
-                    result = "invalid",
-                    bucket = %bucket,
-                    error = %err,
-                    "Failed to parse on-demand migration config"
-                );
-                self.publish_for_incarnation(bucket, incarnation_id, None);
-            }
-        }
-    }
-
     /// Hook entry point: removals apply immediately, installs are spawned
     /// (client construction is async). Requires a Tokio runtime for the
     /// install path; without one the config is logged and skipped.
-    pub fn publish_for_incarnation(
-        &'static self,
-        bucket: &str,
-        incarnation_id: uuid::Uuid,
-        config: Option<&OnDemandMigrationConfig>,
-    ) {
-        let config = self.desired(config).filter(|_| !incarnation_id.is_nil());
-        let generation = self.reserve_generation(bucket, config.is_some());
-        let Some(config) = config else {
+    pub fn publish(&'static self, bucket: &str, config: Option<&OnDemandMigrationConfig>) {
+        let generation = self.next_generation();
+        let Some(config) = self.desired(config) else {
             self.remove_with_generation(bucket, generation);
             return;
         };
-        if self.is_unchanged(bucket, incarnation_id, config, generation) {
+        if self.is_unchanged(bucket, config, generation) {
             return;
         }
         let Ok(handle) = tokio::runtime::Handle::try_current() else {
@@ -812,49 +770,31 @@ impl OnDemandMigrationSys {
         let bucket = bucket.to_string();
         let config = config.clone();
         handle.spawn(async move {
-            self.apply_with_generation(&bucket, incarnation_id, Some(&config), generation)
-                .await;
+            self.apply_with_generation(&bucket, Some(&config), generation).await;
         });
     }
 
     /// Installs, rebuilds, or removes the bucket state for `config`.
     /// Idempotent: the same config on an installed bucket is a no-op.
-    #[cfg(test)]
     pub async fn apply(&self, bucket: &str, config: Option<&OnDemandMigrationConfig>) -> ApplyOutcome {
-        self.apply_for_incarnation(bucket, uuid::Uuid::from_u128(1), config).await
-    }
-
-    #[cfg(test)]
-    pub fn publish(&'static self, bucket: &str, config: Option<&OnDemandMigrationConfig>) {
-        self.publish_for_incarnation(bucket, uuid::Uuid::from_u128(1), config);
-    }
-
-    pub async fn apply_for_incarnation(
-        &self,
-        bucket: &str,
-        incarnation_id: uuid::Uuid,
-        config: Option<&OnDemandMigrationConfig>,
-    ) -> ApplyOutcome {
-        let config = self.desired(config).filter(|_| !incarnation_id.is_nil());
-        let generation = self.reserve_generation(bucket, config.is_some());
-        self.apply_with_generation(bucket, incarnation_id, config, generation).await
+        let generation = self.next_generation();
+        self.apply_with_generation(bucket, config, generation).await
     }
 
     async fn apply_with_generation(
         &self,
         bucket: &str,
-        incarnation_id: uuid::Uuid,
         config: Option<&OnDemandMigrationConfig>,
         generation: u64,
     ) -> ApplyOutcome {
         let Some(config) = self.desired(config) else {
             return self.remove_with_generation(bucket, generation);
         };
-        if self.is_unchanged(bucket, incarnation_id, config, generation) {
+        if self.is_unchanged(bucket, config, generation) {
             return ApplyOutcome::Unchanged;
         }
         let stats = self.state(bucket).map(|state| Arc::clone(&state.stats)).unwrap_or_default();
-        let state = BucketOdmState::build(bucket, config, incarnation_id, stats, self.write_back()).await;
+        let state = BucketOdmState::build(bucket, config, stats, self.write_back()).await;
 
         let (outcome, previous) = {
             let mut buckets = self.buckets.write();
@@ -898,13 +838,12 @@ impl OnDemandMigrationSys {
 
     /// Removes a bucket's state (idempotent), cancelling its token.
     pub fn remove(&self, bucket: &str) -> ApplyOutcome {
-        let generation = self.reserve_generation(bucket, false);
+        let generation = self.next_generation();
         self.remove_with_generation(bucket, generation)
     }
 
     /// One-shot lookup: module switch, bucket state, prefix filter,
     /// client availability, negative cache, breaker, in that order.
-    #[cfg(test)]
     pub fn resolve(&self, bucket: &str, key: &str) -> Option<OdmLookup> {
         if !self.is_module_enabled() {
             return None;
@@ -912,13 +851,6 @@ impl OnDemandMigrationSys {
         self.state(bucket)?.resolve_key(key)
     }
 
-    pub fn resolve_for_incarnation(&self, bucket: &str, key: &str, incarnation_id: uuid::Uuid) -> Option<OdmLookup> {
-        if !self.is_module_enabled() {
-            return None;
-        }
-        self.state(bucket)?.filter_incarnation(incarnation_id)?.resolve_key(key)
-    }
-
     pub fn state(&self, bucket: &str) -> Option<Arc<BucketOdmState>> {
         self.buckets.read().get(bucket).and_then(|slot| slot.state.clone())
     }
@@ -947,17 +879,8 @@ impl OnDemandMigrationSys {
         snapshots
     }
 
-    fn reserve_generation(&self, bucket: &str, installing: bool) -> u64 {
-        // Reserve a desired install before its async client build, under the
-        // same lock that orders removals. Unconfigured buckets need no slot.
-        let mut buckets = self.buckets.write();
-        let generation = self.generation.fetch_add(1, Ordering::Relaxed) + 1;
-        if installing {
-            buckets.entry(bucket.to_string()).or_default().generation = generation;
-        } else if let Some(slot) = buckets.get_mut(bucket) {
-            slot.generation = generation;
-        }
-        generation
+    fn next_generation(&self) -> u64 {
+        self.generation.fetch_add(1, Ordering::Relaxed) + 1
     }
 
     fn desired<'c>(&self, config: Option<&'c OnDemandMigrationConfig>) -> Option<&'c OnDemandMigrationConfig> {
@@ -966,26 +889,15 @@ impl OnDemandMigrationSys {
 
     /// Claims `generation` for the bucket when the installed state already
     /// matches `config` and has a usable client.
-    fn is_unchanged(&self, bucket: &str, incarnation_id: uuid::Uuid, config: &OnDemandMigrationConfig, generation: u64) -> bool {
+    fn is_unchanged(&self, bucket: &str, config: &OnDemandMigrationConfig, generation: u64) -> bool {
         let mut buckets = self.buckets.write();
         let Some(slot) = buckets.get_mut(bucket) else {
             return false;
         };
-        if slot.generation > generation {
-            return false;
-        }
-        if slot
-            .state
-            .as_ref()
-            .is_some_and(|state| state.incarnation_id != incarnation_id)
-            && let Some(previous) = slot.state.take()
-        {
-            previous.cancel.cancel();
-        }
         let unchanged = slot
             .state
             .as_ref()
-            .is_some_and(|state| state.client.is_ok() && state.incarnation_id == incarnation_id && state.config == *config);
+            .is_some_and(|state| state.client.is_ok() && state.config == *config);
         if unchanged && slot.generation < generation {
             slot.generation = generation;
         }
@@ -1025,8 +937,8 @@ impl OnDemandMigrationSys {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::on_demand_migration::breaker::BREAKER_FAILURE_THRESHOLD;
-    use crate::on_demand_migration::config::{FilterConfig, PolicyConfig, SourceCredentials, SourceTimeout, TlsConfig};
+    use crate::bucket::on_demand_migration::breaker::BREAKER_FAILURE_THRESHOLD;
+    use crate::bucket::on_demand_migration::config::{FilterConfig, PolicyConfig, SourceCredentials, SourceTimeout, TlsConfig};
     use std::sync::atomic::AtomicUsize;
     use tokio::sync::Barrier;
 
@@ -1164,45 +1076,6 @@ mod tests {
         assert_eq!(sys.apply("b", Some(&cfg)).await, ApplyOutcome::Rebuilt);
     }
 
-    #[tokio::test]
-    async fn native_azure_uses_provider_credentials_without_s3_credentials() {
-        let sys = enabled_sys();
-        let mut cfg = config(None);
-        cfg.source.provider = Provider::Azure;
-        cfg.source.endpoint = None;
-        cfg.source.credentials = None;
-        cfg.source.azure = Some(super::super::config::AzureSourceConfig {
-            account: "legacyaccount".to_string(),
-            account_key: Some("c2VjcmV0LWtleQ==".to_string()),
-            sas_token: None,
-        });
-        assert_eq!(sys.apply("b", Some(&cfg)).await, ApplyOutcome::Installed);
-        let state = ready_state(sys.resolve("b", "k"));
-        assert!(state.client().is_ok(), "native credentials must not be classified as anonymous S3");
-    }
-
-    #[cfg(not(feature = "gcs"))]
-    #[tokio::test]
-    async fn gcs_backend_not_compiled_is_unavailable_not_anonymous() {
-        let sys = enabled_sys();
-        let mut cfg = config(None);
-        cfg.source.provider = Provider::GcsNative;
-        cfg.source.credentials = None;
-        cfg.source.gcs = Some(super::super::config::GcsSourceConfig {
-            service_account_json: "{}".to_string(),
-        });
-        let encoded = cfg.to_json().expect("GCS config is serializable without the backend");
-        let restored: OnDemandMigrationConfig = serde_json::from_slice(&encoded).expect("GCS config stays readable");
-        assert_eq!(restored, cfg);
-        assert_eq!(sys.apply("b", Some(&cfg)).await, ApplyOutcome::Installed);
-        match sys.resolve("b", "k") {
-            Some(OdmLookup::Unavailable { error, .. }) => {
-                assert_eq!(error, OdmStateError::BackendNotCompiled("gcs_native"));
-            }
-            other => panic!("expected unavailable backend, got {other:?}"),
-        }
-    }
-
     #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
     async fn singleflight_admits_one_leader_per_key() {
         let sys = enabled_sys();
@@ -1418,128 +1291,24 @@ mod tests {
         assert!(state.is_cancelled());
     }
 
-    #[tokio::test]
-    async fn identical_config_on_recreated_bucket_cancels_old_state() {
-        let sys = enabled_sys();
-        let cfg = config(None);
-        let old_id = uuid::Uuid::new_v4();
-        let new_id = uuid::Uuid::new_v4();
-        sys.apply_for_incarnation("recreated", old_id, Some(&cfg)).await;
-        let old = sys.state("recreated").expect("old state installed");
-        assert!(sys.resolve_for_incarnation("recreated", "key", new_id).is_none());
-        sys.apply_for_incarnation("recreated", new_id, Some(&cfg)).await;
-        let replacement = sys.state("recreated").expect("replacement state installed");
-        assert!(old.is_cancelled());
-        assert!(!Arc::ptr_eq(&old, &replacement));
-        assert_eq!(replacement.incarnation_id(), new_id);
-        assert!(sys.resolve_for_incarnation("recreated", "key", old_id).is_none());
-        assert!(sys.resolve_for_incarnation("recreated", "key", new_id).is_some());
-    }
-
-    #[tokio::test]
-    async fn changed_delete_marker_policy_withdraws_the_captured_lookup() {
-        let sys = enabled_sys();
-        let incarnation = uuid::Uuid::new_v4();
-        let mut cfg = config(None);
-        cfg.policy.respect_local_delete_marker = false;
-        sys.apply_for_incarnation("policy-snapshot", incarnation, Some(&cfg)).await;
-        let captured = sys.state("policy-snapshot").expect("policy A installed");
-        assert!(!captured.config().policy.respect_local_delete_marker);
-
-        cfg.policy.respect_local_delete_marker = true;
-        sys.apply_for_incarnation("policy-snapshot", incarnation, Some(&cfg)).await;
-        let replacement = sys.state("policy-snapshot").expect("policy B installed");
-        assert!(replacement.config().policy.respect_local_delete_marker);
-        assert!(captured.is_cancelled());
-        assert!(
-            captured
-                .filter_incarnation(incarnation)
-                .and_then(|state| state.resolve_key("key"))
-                .is_none(),
-            "a request that evaluated policy A cannot continue through policy B"
-        );
-        assert!(
-            replacement
-                .clone()
-                .filter_incarnation(incarnation)
-                .and_then(|state| state.resolve_key("key"))
-                .is_some()
-        );
-        assert_eq!(
-            replacement
-                .stats()
-                .snapshot(replacement.breaker().state())
-                .source_latency
-                .count,
-            0
-        );
-    }
-
-    #[tokio::test]
-    async fn missing_incarnation_cannot_install_or_retain_source_state() {
-        let sys: &'static OnDemandMigrationSys = Box::leak(Box::new(enabled_sys()));
-        let cfg = config(None);
-        assert_eq!(
-            sys.apply_for_incarnation("missing", uuid::Uuid::nil(), Some(&cfg)).await,
-            ApplyOutcome::NotDesired
-        );
-        sys.publish_for_incarnation("missing", uuid::Uuid::nil(), Some(&cfg));
-        assert!(sys.state("missing").is_none());
-
-        sys.apply_for_incarnation("missing", uuid::Uuid::new_v4(), Some(&cfg)).await;
-        let state = sys.state("missing").expect("valid identity installed");
-        sys.publish_for_incarnation("missing", uuid::Uuid::nil(), Some(&cfg));
-        assert!(sys.state("missing").is_none());
-        assert!(state.is_cancelled());
-    }
-
-    #[tokio::test]
-    async fn corrupt_stored_config_withdraws_runtime_state() {
-        let sys: &'static OnDemandMigrationSys = Box::leak(Box::new(enabled_sys()));
-        let cfg = config(None);
-        assert_eq!(sys.apply("corrupt", Some(&cfg)).await, ApplyOutcome::Installed);
-        let state = sys.state("corrupt").expect("state installed");
-        sys.publish_stored("corrupt", Some((b"not-json", uuid::Uuid::from_u128(1))));
-        assert!(sys.state("corrupt").is_none(), "corruption cannot keep an older source active");
-        assert!(state.is_cancelled(), "corruption cancels in-flight work");
-    }
-
-    #[tokio::test]
-    async fn absent_config_updates_do_not_allocate_bucket_slots() {
-        let sys = enabled_sys();
-        for index in 0..1000 {
-            let bucket = format!("unconfigured-{index}");
-            assert_eq!(sys.apply(&bucket, None).await, ApplyOutcome::NotDesired);
-            assert_eq!(sys.remove(&bucket), ApplyOutcome::NotDesired);
-        }
-        assert!(sys.buckets.read().is_empty(), "unconfigured buckets must not accumulate tombstones");
-    }
-
     #[tokio::test]
     async fn stale_install_cannot_overwrite_a_later_removal() {
         let sys = enabled_sys();
         let cfg = config(None);
-        let older = sys.reserve_generation("b", true);
-        let newer = sys.reserve_generation("b", false);
+        let older = sys.next_generation();
+        let newer = sys.next_generation();
         assert_eq!(sys.remove_with_generation("b", newer), ApplyOutcome::NotDesired);
-        assert_eq!(
-            sys.apply_with_generation("b", uuid::Uuid::from_u128(1), Some(&cfg), older)
-                .await,
-            ApplyOutcome::Superseded
-        );
-        assert!(sys.state("b").is_none(), "removal must supersede an in-flight first install");
+        // The removal above did not create a slot; simulate an install that
+        // started before it and finishes after.
+        sys.apply_with_generation("b", Some(&cfg), older).await;
+        assert!(sys.state("b").is_some(), "no slot yet, so the older install lands");
 
-        assert_eq!(sys.apply("b", Some(&cfg)).await, ApplyOutcome::Installed);
         let installed = sys.state("b").unwrap();
-        let older = sys.reserve_generation("b", true);
-        let newer = sys.reserve_generation("b", false);
+        let older = sys.next_generation();
+        let newer = sys.next_generation();
         assert_eq!(sys.remove_with_generation("b", newer), ApplyOutcome::Removed);
         assert!(installed.is_cancelled());
-        assert_eq!(
-            sys.apply_with_generation("b", uuid::Uuid::from_u128(1), Some(&cfg), older)
-                .await,
-            ApplyOutcome::Superseded
-        );
+        assert_eq!(sys.apply_with_generation("b", Some(&cfg), older).await, ApplyOutcome::Superseded);
         assert!(sys.state("b").is_none(), "the stale install is discarded");
     }
 

crates/ecstore/src/bucket/remote_s3_client.rs

@@ -180,8 +180,6 @@ impl RemoteS3EndpointSpec {
 
 #[derive(Debug, thiserror::Error)]
 pub enum RemoteS3ClientError {
-    #[error("the {0} backend is not included in this build")]
-    BackendNotCompiled(&'static str),
     #[error("remote endpoint requires credentials")]
     MissingCredentials,
     #[error("{0}")]
@@ -283,7 +281,9 @@ impl Intercept for UserAgentSuffixInterceptor {
 
 /// Builds the SDK config for `spec` without finalizing it, so callers can add
 /// interceptors or (in tests) swap the HTTP client before `build()`.
-pub async fn build_remote_s3_config(spec: &RemoteS3EndpointSpec) -> Result<aws_sdk_s3::config::Builder, RemoteS3ClientError> {
+pub(crate) async fn build_remote_s3_config(
+    spec: &RemoteS3EndpointSpec,
+) -> Result<aws_sdk_s3::config::Builder, RemoteS3ClientError> {
     let Some(credentials) = &spec.credentials else {
         return Err(RemoteS3ClientError::MissingCredentials);
     };
@@ -523,7 +523,7 @@ fn validate_ca_pem_bundle(ca_cert_pem: &[u8]) -> Result<(), String> {
     Ok(())
 }
 
-pub fn validate_target_ca_pem(ca_cert_pem: &str) -> Result<(), RemoteS3ClientError> {
+pub(crate) fn validate_target_ca_pem(ca_cert_pem: &str) -> Result<(), RemoteS3ClientError> {
     validate_ca_pem_bundle(ca_cert_pem.as_bytes()).map_err(RemoteS3ClientError::InvalidCaPem)
 }
 

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

@@ -25,7 +25,6 @@ pub(crate) mod tier_probe_intent;
 pub mod warm_backend;
 pub mod warm_backend_aliyun;
 pub mod warm_backend_azure;
-#[cfg(feature = "gcs")]
 pub mod warm_backend_gcs;
 pub mod warm_backend_huaweicloud;
 pub mod warm_backend_minio;

crates/ecstore/src/services/tier/warm_backend.rs

@@ -19,14 +19,13 @@
 #![allow(clippy::all)]
 
 use crate::error::is_err_bucket_not_found;
-#[cfg(feature = "gcs")]
-use crate::services::tier::warm_backend_gcs::WarmBackendGCS;
 use crate::services::tier::{
     tier::{ERR_TIER_BACKEND_IN_USE, ERR_TIER_INVALID_CONFIG, ERR_TIER_TYPE_UNSUPPORTED},
     tier_config::{TierConfig, TierType},
     tier_handlers::{ERR_TIER_BUCKET_NOT_FOUND, ERR_TIER_NOT_FOUND, ERR_TIER_PERM_ERR},
     warm_backend_aliyun::WarmBackendAliyun,
     warm_backend_azure::WarmBackendAzure,
+    warm_backend_gcs::WarmBackendGCS,
     warm_backend_huaweicloud::WarmBackendHuaweicloud,
     warm_backend_minio::WarmBackendMinIO,
     warm_backend_r2::WarmBackendR2,
@@ -913,15 +912,6 @@ pub async fn new_warm_backend(tier: &TierConfig, probe: bool) -> Result<WarmBack
                 });
             }
         }
-        #[cfg(not(feature = "gcs"))]
-        TierType::GCS => {
-            return Err(AdminError {
-                code: ERR_TIER_TYPE_UNSUPPORTED.code.clone(),
-                message: "This build does not include the GCS backend; rebuild with the gcs feature".to_string(),
-                status_code: StatusCode::NOT_IMPLEMENTED,
-            });
-        }
-        #[cfg(feature = "gcs")]
         TierType::GCS => {
             if let Some(gcs_config) = tier.gcs.as_ref() {
                 let dd = WarmBackendGCS::new(gcs_config, &tier.name).await;
@@ -1038,27 +1028,6 @@ mod tests {
 
     const PROBE_VERSION: &str = "remote-v2";
 
-    #[cfg(not(feature = "gcs"))]
-    #[tokio::test]
-    async fn gcs_backend_not_compiled_preserves_config() {
-        let json = r#"{"name":"ARCHIVE","type":"gcs","gcs":{"bucket":"archive","creds":"secret"}}"#;
-        let tier: TierConfig = serde_json::from_str(json).expect("GCS config remains readable without the backend");
-        assert_eq!(tier.tier_type, TierType::GCS);
-        let encoded = serde_json::to_vec(&tier).expect("GCS config remains writable");
-        let restored: TierConfig = serde_json::from_slice(&encoded).expect("GCS config round trips");
-        assert_eq!(restored.tier_type, TierType::GCS);
-        let restored_gcs = restored.gcs.as_ref().expect("GCS settings preserved");
-        assert_eq!(restored_gcs.bucket, "archive");
-        assert_eq!(restored_gcs.creds, "secret");
-        assert_eq!(tier.redacted().gcs.expect("redacted GCS settings").creds, "REDACTED");
-        let error = match new_warm_backend(&tier, false).await {
-            Ok(_) => panic!("an excluded GCS backend cannot be constructed"),
-            Err(error) => error,
-        };
-        assert_eq!(error.code, ERR_TIER_TYPE_UNSUPPORTED.code);
-        assert_eq!(error.status_code, StatusCode::NOT_IMPLEMENTED);
-    }
-
     struct CountingBackend {
         put_result: fn() -> Result<String, std::io::Error>,
         removes: Arc<AtomicUsize>,

crates/ecstore/src/store/bucket.rs

@@ -329,11 +329,11 @@ impl ECStore {
     /// reuse its result, which is sound because bucket deletion/recreation
     /// requires the lifecycle WRITE lock and therefore cannot have run while
     /// any read guard was continuously held.
-    pub async fn acquire_bucket_incarnation_fence(
+    pub(crate) async fn acquire_bucket_incarnation_fence(
         &self,
         bucket: &str,
         expected: uuid::Uuid,
-    ) -> Result<super::BucketIncarnationFenceGuard> {
+    ) -> Result<super::bucket_fence::BucketIncarnationFenceGuard> {
         let inner = self.acquire_bucket_lifecycle_read_lock(bucket).await?;
         let pieces = super::bucket_fence::FencePieces {
             registry: self.bucket_fence_registry.clone(),

crates/ecstore/src/store/bucket_fence.rs

@@ -150,7 +150,7 @@ impl BucketFenceRegistry {
 /// A held bucket lifecycle read lock plus its registration in the fence
 /// registry. Dropping the guard deregisters it; the memo is cleared when the
 /// last guard for the bucket drops (or a lost lock is observed).
-pub struct BucketIncarnationFenceGuard {
+pub(crate) struct BucketIncarnationFenceGuard {
     inner: Option<NamespaceLockGuard>,
     registry: Arc<BucketFenceRegistry>,
     bucket: String,
@@ -158,14 +158,6 @@ pub struct BucketIncarnationFenceGuard {
 }
 
 impl BucketIncarnationFenceGuard {
-    /// Propagate lifecycle lock loss into the storage commit checks.
-    /// The caller still owns this guard until the complete write tail drains.
-    pub fn attach_to_object_options(&self, opts: &mut crate::object_api::ObjectOptions) {
-        if let Some(guard) = self.namespace_lock_guard() {
-            opts.add_bucket_lifecycle_lock_guard(guard);
-        }
-    }
-
     pub(crate) fn is_lock_lost(&self) -> bool {
         self.inner.as_ref().is_some_and(NamespaceLockGuard::is_lock_lost)
     }
@@ -354,36 +346,6 @@ mod tests {
         first_pieces.abandon("b", first.token);
     }
 
-    #[tokio::test]
-    async fn checkpoint_options_inherit_bucket_fence_lock_loss() {
-        let lock = NamespaceLock::new("bucket-fence-options".to_string(), Arc::new(LocalClient::new()));
-        let inner = lock
-            .acquire_guard(&lock_request("options"))
-            .await
-            .expect("acquire")
-            .expect("quorum");
-        let pieces = FencePieces {
-            registry: Arc::default(),
-            inner,
-        };
-        let registration = pieces.enter("b");
-        let fence = pieces.into_guard("b", registration.token);
-        let mut opts = crate::object_api::ObjectOptions::default();
-        fence.attach_to_object_options(&mut opts);
-        let inherited = opts
-            .bucket_lifecycle_lock_fence
-            .as_ref()
-            .expect("checkpoint inherits lifecycle guard");
-        assert!(!inherited.is_lock_lost());
-        tokio::time::timeout(
-            Duration::from_secs(2),
-            fence.namespace_lock_guard().expect("held guard").lock_lost_notified(),
-        )
-        .await
-        .expect("distributed guard expires");
-        assert!(inherited.is_lock_lost(), "the actual pre-rename options must observe lifecycle lock loss");
-    }
-
     #[test]
     fn buckets_are_isolated() {
         let reg = BucketFenceRegistry::default();

crates/ecstore/src/store/init.rs

@@ -353,11 +353,6 @@ async fn resume_rebalance_after_init(store: Arc<ECStore>, rx: CancellationToken)
 }
 
 impl ECStore {
-    /// Shutdown token owned by this store instance.
-    pub fn background_cancel_token(&self) -> Option<CancellationToken> {
-        self.ctx.background_cancel_token()
-    }
-
     /// Validate topology and process storage-class overrides before any disk is opened.
     pub fn validate_startup_storage_class(endpoint_pools: &EndpointServerPools) -> Result<()> {
         let drive_counts = startup_pool_drive_counts(endpoint_pools);

crates/ecstore/src/store/mod.rs

@@ -417,7 +417,6 @@ const MAX_UPLOADS_LIST: usize = 10000;
 mod bucket;
 mod bucket_fence;
 pub(crate) use bucket::await_bucket_namespace_operation;
-pub use bucket_fence::BucketIncarnationFenceGuard;
 mod heal;
 mod heal_walk;
 pub use heal_walk::HealWalkVersion;

crates/madmin/src/on_demand_migration.rs

@@ -17,7 +17,7 @@
 //! Wire types for `PUT`/`GET`/`DELETE /v3/on-demand-migration/{bucket}`,
 //! `GET .../status`, `POST .../backfill?op=start|cancel` and
 //! `GET .../backfill` (ODM-12), mirroring the server's config model
-//! (`rustfs/src/on_demand_migration/config.rs`) and handler
+//! (`crates/ecstore/src/bucket/on_demand_migration/config.rs`) and handler
 //! responses (`rustfs/src/admin/handlers/on_demand_migration.rs`). The SDK
 //! owns its own copies, madmin-go style; the fixtures under
 //! `fixtures/on_demand_migration/` are the contract both sides pin

crates/obs/src/metrics/mod.rs

@@ -38,4 +38,3 @@ pub(crate) use storage_api::metrics::{
     obs_on_demand_migration_snapshot, obs_replication_site_stats_snapshot, obs_resolve_object_store_handle,
     obs_transition_state_handle,
 };
-pub use storage_api::register_on_demand_migration_metrics_source;

crates/obs/src/metrics/storage_api.rs

@@ -17,6 +17,13 @@ use std::time::Duration;
 
 pub(crate) use rustfs_ecstore::api::bucket::bandwidth::monitor::Monitor as ObsBucketBandwidthMonitor;
 pub(crate) use rustfs_ecstore::api::bucket::metadata_sys::get_quota_config as obs_get_quota_config;
+use rustfs_ecstore::api::bucket::on_demand_migration::backfill::{
+    BackfillCheckpoint as SourceBackfillCheckpoint, global_backfill_runner as source_global_backfill_runner,
+};
+use rustfs_ecstore::api::bucket::on_demand_migration::{
+    BreakerState as SourceOdmBreakerState, OdmBucketSnapshot as SourceOdmBucketSnapshot,
+    OnDemandMigrationSys as SourceOnDemandMigrationSys,
+};
 use rustfs_ecstore::api::bucket::replication::{
     BucketReplicationStats as SourceBucketReplicationStats, DurableMrfBucketBacklog, DurableMrfTargetBacklog,
     MrfBucketBacklogObservability, RuntimeReplicationTargetBacklog, durable_mrf_backlog_summary_snapshot,
@@ -37,7 +44,9 @@ pub(crate) use rustfs_ecstore::api::runtime::{
 pub(crate) use rustfs_ecstore::api::storage::ECStore as ObsStore;
 use rustfs_storage_api as storage_contracts;
 
-use crate::metrics::collectors::{OdmBackfillBucketStats, OdmBackfillRuntimeStats, OnDemandMigrationBucketStats};
+use crate::metrics::collectors::{
+    OdmBackfillBucketStats, OdmBackfillRuntimeStats, OnDemandMigrationBreakerState, OnDemandMigrationBucketStats,
+};
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct ObsBucketReplicationTargetStatsSnapshot {
@@ -456,37 +465,70 @@ pub(crate) async fn obs_bucket_replication_stats_snapshot() -> Vec<ObsBucketRepl
     buckets
 }
 
-struct OnDemandMigrationMetricsSource {
-    snapshot: fn() -> Vec<OnDemandMigrationBucketStats>,
-    backfill_snapshot: fn() -> Vec<OdmBackfillBucketStats>,
-}
-
-static ON_DEMAND_MIGRATION_METRICS_SOURCE: std::sync::OnceLock<OnDemandMigrationMetricsSource> = std::sync::OnceLock::new();
-
-/// Register the application-owned ODM snapshots before starting the collector.
-pub fn register_on_demand_migration_metrics_source(
-    snapshot: fn() -> Vec<OnDemandMigrationBucketStats>,
-    backfill_snapshot: fn() -> Vec<OdmBackfillBucketStats>,
-) -> bool {
-    ON_DEMAND_MIGRATION_METRICS_SOURCE
-        .set(OnDemandMigrationMetricsSource {
-            snapshot,
-            backfill_snapshot,
-        })
-        .is_ok()
+fn on_demand_migration_stats_from_snapshot(snapshot: SourceOdmBucketSnapshot) -> OnDemandMigrationBucketStats {
+    let stats = snapshot.stats;
+    OnDemandMigrationBucketStats {
+        bucket: snapshot.bucket,
+        requests_total: stats.requests_total,
+        pulled_bytes_total: stats.pulled_bytes_total,
+        pulled_objects_total: stats.pulled_objects_total,
+        pull_failures_total: stats.pull_failures_total,
+        inflight_pulls: stats.inflight_pulls,
+        queue_depth: stats.queue_depth,
+        source_latency_buckets: stats
+            .source_latency
+            .buckets
+            .into_iter()
+            .map(|bucket| (bucket.le_ms, bucket.count))
+            .collect(),
+        source_latency_count: stats.source_latency.count,
+        source_latency_sum_ms: stats.source_latency.sum_ms,
+        breaker_state: match stats.breaker_state {
+            SourceOdmBreakerState::Closed => OnDemandMigrationBreakerState::Closed,
+            SourceOdmBreakerState::HalfOpen => OnDemandMigrationBreakerState::HalfOpen,
+            SourceOdmBreakerState::Open => OnDemandMigrationBreakerState::Open,
+        },
+    }
 }
 
+/// Every bucket with live on-demand migration state on this node, sorted by
+/// name. Empty while the module switch is off.
 pub(crate) fn obs_on_demand_migration_snapshot() -> Vec<OnDemandMigrationBucketStats> {
-    ON_DEMAND_MIGRATION_METRICS_SOURCE
-        .get()
-        .map(|source| (source.snapshot)())
-        .unwrap_or_default()
+    SourceOnDemandMigrationSys::get()
+        .snapshot()
+        .into_iter()
+        .map(on_demand_migration_stats_from_snapshot)
+        .collect()
 }
 
+fn on_demand_migration_backfill_stats_from_checkpoint(
+    bucket: String,
+    checkpoint: SourceBackfillCheckpoint,
+) -> OdmBackfillBucketStats {
+    OdmBackfillBucketStats {
+        bucket,
+        state: checkpoint.state.as_str().to_string(),
+        listed: checkpoint.listed,
+        enqueued: checkpoint.enqueued,
+        pulled: checkpoint.pulled,
+        skipped_existing: checkpoint.skipped_existing,
+        failed: checkpoint.failed,
+        bytes: checkpoint.bytes,
+    }
+}
+
+/// Backfill jobs running on this node, sorted by bucket. Empty until the
+/// runner is installed, and empty again once a job finishes: the series are
+/// per-node job progress, not a cluster-wide history.
 pub(crate) fn obs_on_demand_migration_backfill_snapshot(server: String) -> OdmBackfillRuntimeStats {
-    let buckets = ON_DEMAND_MIGRATION_METRICS_SOURCE
-        .get()
-        .map(|source| (source.backfill_snapshot)())
+    let buckets = source_global_backfill_runner()
+        .map(|runner| {
+            runner
+                .local_job_snapshots()
+                .into_iter()
+                .map(|(bucket, checkpoint)| on_demand_migration_backfill_stats_from_checkpoint(bucket, checkpoint))
+                .collect()
+        })
         .unwrap_or_default();
     OdmBackfillRuntimeStats { server, buckets }
 }
@@ -538,31 +580,6 @@ pub(crate) async fn obs_replication_site_stats_snapshot(current_data_transfer_ra
 mod tests {
     use super::*;
 
-    #[test]
-    fn on_demand_migration_callbacks_supply_runtime_snapshots() {
-        assert!(register_on_demand_migration_metrics_source(
-            || vec![OnDemandMigrationBucketStats {
-                bucket: "configured".into(),
-                pulled_bytes_total: 4096,
-                ..Default::default()
-            }],
-            || vec![OdmBackfillBucketStats {
-                bucket: "backfill".into(),
-                pulled: 3,
-                ..Default::default()
-            }],
-        ));
-        let snapshot = obs_on_demand_migration_snapshot();
-        assert_eq!(snapshot.len(), 1);
-        assert_eq!(snapshot[0].bucket, "configured");
-        assert_eq!(snapshot[0].pulled_bytes_total, 4096);
-        let backfill = obs_on_demand_migration_backfill_snapshot("node-a".into());
-        assert_eq!(backfill.server, "node-a");
-        assert_eq!(backfill.buckets.len(), 1);
-        assert_eq!(backfill.buckets[0].bucket, "backfill");
-        assert_eq!(backfill.buckets[0].pulled, 3);
-    }
-
     #[test]
     fn obs_replication_numeric_conversions_floor_negative_values() {
         assert_eq!(i64_to_u64_floor_zero(-1), 0);
@@ -755,6 +772,51 @@ mod tests {
         assert_eq!(snapshot.mrf_last_flush_duration_millis, 4);
     }
 
+    #[test]
+    fn on_demand_migration_snapshot_projects_counters_and_breaker_state() {
+        // Built from JSON: the snapshot's timestamps use `time`, which obs does not depend on.
+        let snapshot: SourceOdmBucketSnapshot = serde_json::from_value(serde_json::json!({
+            "bucket": "photos",
+            "provider": "minio",
+            "endpoint_host": "source.example.com",
+            "applied_at": "2026-09-02T10:00:00Z",
+            "client_error": null,
+            "negative_cache_entries": 0,
+            "inflight_keys": 1,
+            "max_concurrent_pulls": 8,
+            "stats": {
+                "requests_total": {"get": {"source_hit": 2}},
+                "pulled_bytes_total": 4096,
+                "pulled_objects_total": {"inline": 1},
+                "pull_failures_total": {"source_timeout": 1},
+                "inflight_pulls": 1,
+                "queue_depth": 2,
+                "source_latency": {
+                    "buckets": [{"le_ms": 5, "count": 1}, {"le_ms": 10, "count": 2}],
+                    "count": 3,
+                    "sum_ms": 90753
+                },
+                "last_source_error": {"class": "server_error", "at": "2026-09-02T10:00:00Z"},
+                "breaker_state": "open"
+            }
+        }))
+        .expect("runtime snapshot decodes");
+
+        let stats = on_demand_migration_stats_from_snapshot(snapshot);
+
+        assert_eq!(stats.bucket, "photos");
+        assert_eq!(stats.requests_total["get"]["source_hit"], 2);
+        assert_eq!(stats.pulled_bytes_total, 4096);
+        assert_eq!(stats.pulled_objects_total["inline"], 1);
+        assert_eq!(stats.pull_failures_total["source_timeout"], 1);
+        assert_eq!(stats.inflight_pulls, 1);
+        assert_eq!(stats.queue_depth, 2);
+        assert_eq!(stats.source_latency_buckets, vec![(5, 1), (10, 2)]);
+        assert_eq!(stats.source_latency_count, 3);
+        assert_eq!(stats.source_latency_sum_ms, 90_753);
+        assert_eq!(stats.breaker_state, OnDemandMigrationBreakerState::Open);
+    }
+
     #[test]
     fn bucket_replication_snapshot_preserves_durable_mrf_unavailable_state() {
         let snapshot = bucket_replication_stats_snapshot_from_parts(

docs/architecture/background-services-inventory.md

@@ -13,8 +13,8 @@ Operator-facing behaviour, configuration, and troubleshooting for these services
 
 | Service | Desired source | Current-status inputs | Status surface | Side effects |
 |---|---|---|---|---|
-| Write-back pull pipeline (`rustfs/src/on_demand_migration/pull.rs`; the local write is delegated to the app layer in `rustfs/src/app/object/on_demand_migration_put.rs`) | The bucket's `on-demand-migration.json` (`enabled`, `policy.max_concurrent_pulls`, `pull_queue_capacity`, `multipart_part_size_bytes`, `bandwidth_limit_bytes_per_sec`) together with the process switch `RUSTFS_ON_DEMAND_MIGRATION_ENABLED` | Per-bucket runtime state in `rustfs/src/on_demand_migration/sys.rs`: whether a state is installed, whether its source client built, its cancellation token, queue depth, in-flight pull permits | `GET /rustfs/admin/v3/on-demand-migration/{bucket}/status` (`inflight_pulls`, `queue_depth`, `counters.pulled_*`, `counters.pull_failures_total`) and the `rustfs_on_demand_migration_*` series | Source GET/HEAD/GetObjectTagging traffic; local object writes through the internal put path, hence quota consumption, bucket default SSE, versioning, Object Lock defaults, `ObjectCreated` notifications, and outbound replication scheduling |
-| Backfill job (module under `rustfs/src/on_demand_migration/`, rustfs/backlog#2159) | An admin `start` request plus the bucket config; invalidated when the config's `updated_at` changes or the config is deleted | The persisted checkpoint under the bucket's metadata prefix, its `state` field, and the owner lease | The backfill section of the bucket status endpoint and the `rustfs_on_demand_migration_backfill_*` series | Source `ListObjectsV2` paging; queue admission into the write-back pipeline (and therefore all of its side effects); checkpoint writes |
-| Backfill recovery loop (registered from `rustfs/src/startup_background.rs`, rustfs/backlog#2159) | The set of persisted checkpoints in `state = running`; runs on every node | Checkpoint owner lease expiry | Takeover is reported through the same backfill status; a takeover emits a warn-level lease event | Claims the lease and resumes the backfill job, inheriting its side effects. Scanning checkpoints is read-only |
+| Write-back pull pipeline (`crates/ecstore/src/bucket/on_demand_migration/pull.rs`; the local write is delegated to the app layer in `rustfs/src/app/object/on_demand_migration_put.rs`) | The bucket's `on-demand-migration.json` (`enabled`, `policy.max_concurrent_pulls`, `pull_queue_capacity`, `multipart_part_size_bytes`, `bandwidth_limit_bytes_per_sec`) together with the process switch `RUSTFS_ON_DEMAND_MIGRATION_ENABLED` | Per-bucket runtime state in `crates/ecstore/src/bucket/on_demand_migration/sys.rs`: whether a state is installed, whether its source client built, its cancellation token, queue depth, in-flight pull permits | `GET /rustfs/admin/v3/on-demand-migration/{bucket}/status` (`inflight_pulls`, `queue_depth`, `counters.pulled_*`, `counters.pull_failures_total`) and the `rustfs_on_demand_migration_*` series | Source GET/HEAD/GetObjectTagging traffic; local object writes through the internal put path, hence quota consumption, bucket default SSE, versioning, Object Lock defaults, `ObjectCreated` notifications, and outbound replication scheduling |
+| Backfill job (module under `crates/ecstore/src/bucket/on_demand_migration/`, rustfs/backlog#2159 — not yet in the tree) | An admin `start` request plus the bucket config; invalidated when the config's `updated_at` changes or the config is deleted | The persisted checkpoint under the bucket's metadata prefix, its `state` field, and the owner lease | The backfill section of the bucket status endpoint and the `rustfs_on_demand_migration_backfill_*` series | Source `ListObjectsV2` paging; queue admission into the write-back pipeline (and therefore all of its side effects); checkpoint writes |
+| Backfill recovery loop (registered from `rustfs/src/startup_background.rs`, rustfs/backlog#2159 — not yet in the tree) | The set of persisted checkpoints in `state = running`; runs on every node | Checkpoint owner lease expiry | Takeover is reported through the same backfill status; a takeover emits a warn-level lease event | Claims the lease and resumes the backfill job, inheriting its side effects. Scanning checkpoints is read-only |
 
 The pull pipeline has no separate loop of its own: a bucket's queue dispatcher starts lazily on the first background pull and is cancelled when the bucket's state is rebuilt or removed, and each inline pull commits in a task that outlives its request so a client disconnect cannot truncate the stored object. Neither the switch nor the config is re-read by the workers: the bucket-metadata publish hook rebuilds the state, which is the only desired-state path.

docs/architecture/crate-boundaries.md

@@ -84,41 +84,3 @@ The server-config model (`Config`, `KV`, `KVS`) and the global server-config sna
 ## Required Architecture Documents
 
 The guard requires the documents and section headings listed in its `require_source_contains` entries (`scripts/check_architecture_migration_rules.sh`); the directory index is [README.md](README.md).
-
-## On-Demand Migration Service
-
-Read-through, backfill and external pull orchestration belong in an application
-service under `rustfs/src/<service>/`. ECStore owns the storage primitives they
-need, including atomic commits, lifecycle locks and on-disk metadata. A service
-may use these primitives without moving its provider clients or scheduling
-policy into the engine.
-
-`rustfs/src/on_demand_migration/` owns source clients, pull scheduling, list
-merging, runtime state and backfill orchestration. Its `storage_api.rs` is the
-only ECStore facade boundary. Object write-back still enters the application's
-internal PUT and multipart use cases, including the atomic create-only commit,
-delete-marker protection, encryption, quota and notification rules.
-
-ECStore stores the existing ODM bytes and update timestamp without interpreting
-the JSON. Every metadata cache install or removal publishes those bytes through
-`BUCKET_CONFIG_PUBLISH_HOOK`; the application decodes them and synchronously
-withdraws corrupt configurations. Configuration writes validate structure and
-deployment constraints in the admin use case before the incarnation-fenced
-metadata update. Backfill reads metadata from its store's instance context and
-preserves the checkpoint ETag compare-and-set, lease and tail-drained writes.
-
-An ODM runtime is bound to the bucket incarnation published with its metadata,
-not just its name. Source reads and write-back reject a different incarnation.
-Checkpoint writes hold the user bucket's lifecycle fence through their complete
-commit and read-back, even if their caller stops waiting; the storage commit
-also observes lock loss. Deleting and recreating a bucket must not let work for
-its previous incarnation repopulate objects or checkpoints.
-
-Observability owns its metric DTOs and accepts application snapshot callbacks;
-it does not depend on the ODM runtime. The application registers both bucket
-and backfill snapshots during startup, before metadata and metric collection.
-
-This boundary does not change `.metadata.bin`, the ODM wire format or the
-backfill checkpoint format. An older binary may still discard unknown metadata
-fields when it rewrites a bucket; service relocation does not make mixed-version
-configuration writes or rollback preserve ODM configuration.

docs/architecture/ecstore-api-facade-inventory.md

@@ -63,10 +63,3 @@ Lifecycle, replication, and `SetDisks` split blockers, extracted contracts, and
 4. Do not replace `SetDisks` with multiple runtime structs in one change; move one operation family only after contracts and focused tests exist.
 5. Remove or narrow one facade group per change so rollback preserves object IO, quorum, lifecycle/replication queues, scanner repair, notification/audit events, and metadata compatibility.
 6. Keep `api::bucket`, `api::config`, `api::disk`, and `api::tier` on explicit submodules and symbol lists; do not restore `pub use crate::<owner>::{...}` whole-module passthroughs for those groups.
-
-### On-Demand Migration
-
-`rustfs/src/on_demand_migration/storage_api.rs` owns the service's storage facade
-imports: opaque bucket configuration, shared remote S3 client construction,
-namespace locking, object options and metadata-object persistence. ODM types
-are owned by the application and are no longer exported through ECStore.

docs/architecture/remote-credential-sealing-adr.md

@@ -1,7 +1,7 @@
 # Remote Credential Sealing ADR
 
 **Use this when:** you add, read, or persist a stored remote credential — a replication target, a remote tier, or an on-demand migration source — or you need the sealed-envelope format, the mixed-version rules, or the reason this is worth doing in one deployment and not in another.
-**Source of truth:** the three stores that hold remote credentials — `BUCKET_TARGETS_FILE` and `BUCKET_ON_DEMAND_MIGRATION_CONFIG` in `crates/ecstore/src/bucket/metadata.rs`, `TIER_CONFIG_FILE` in `crates/ecstore/src/services/tier/tier.rs` — the shared envelope in `crates/ecstore/src/bucket/sealed_credentials.rs`, the consumers `crates/ecstore/src/bucket/bucket_target_sys.rs`, `crates/ecstore/src/services/tier/tier_config.rs` and `rustfs/src/on_demand_migration/config.rs`, and the backend properties in [../operations/kms-backend-security.md](../operations/kms-backend-security.md).
+**Source of truth:** the three stores that hold remote credentials — `BUCKET_TARGETS_FILE` and `BUCKET_ON_DEMAND_MIGRATION_CONFIG` in `crates/ecstore/src/bucket/metadata.rs`, `TIER_CONFIG_FILE` in `crates/ecstore/src/services/tier/tier.rs` — the shared envelope in `crates/ecstore/src/bucket/sealed_credentials.rs`, the consumers `crates/ecstore/src/bucket/bucket_target_sys.rs`, `crates/ecstore/src/services/tier/tier_config.rs` and `crates/ecstore/src/bucket/on_demand_migration/config.rs`, and the backend properties in [../operations/kms-backend-security.md](../operations/kms-backend-security.md).
 
 ## Recommendation
 
@@ -37,7 +37,7 @@ Two of the three are not files at all. `bucket-targets.json` and `on-demand-migr
 | Store | Reached as | Actually persisted at | Written by | Container |
 |---|---|---|---|---|
 | Replication and ILM targets | `BUCKET_TARGETS_FILE` | `BucketMetadata::bucket_targets_config_json`, msgpack field `BucketTargetsConfigJSON` | `BucketMetadata::update_config`, then `BucketMetadata::save_with_store`; `crates/ecstore/src/bucket/metadata_sys.rs` serializes the update under a transaction lock | `{BUCKET_META_PREFIX}/{bucket}/{BUCKET_METADATA_FILE}` in `RUSTFS_META_BUCKET` (`crates/ecstore/src/disk/mod.rs`) |
-| On-demand migration source | `BUCKET_ON_DEMAND_MIGRATION_CONFIG` | `BucketMetadata::on_demand_migration_config_json`, msgpack field `OnDemandMigrationConfigJSON` | same path; the application validates structure and deployment constraints before persistence | same blob as above |
+| On-demand migration source | `BUCKET_ON_DEMAND_MIGRATION_CONFIG` | `BucketMetadata::on_demand_migration_config_json`, msgpack field `OnDemandMigrationConfigJSON` | same path; `update_config` additionally refuses a blob this build cannot parse | same blob as above |
 | Remote tiers | `TIER_CONFIG_FILE` | its own object, a four-byte `TIER_CONFIG_FORMAT` / `TIER_CONFIG_VERSION` header followed by an `rmp_serde` payload of `ExternalTierConfigMgr` | `TierConfigMgr` through `encode_external_tiering_config_blob`, under `tier_config_lock_path` | `tier_config_path` under `CONFIG_PREFIX` in `RUSTFS_META_BUCKET` |
 
 The consequence of the first two sharing a blob is that any change to how that blob parses has a blast radius covering policy, lifecycle, versioning, object lock and everything else in `BucketMetadata` — not just credentials.
@@ -48,7 +48,7 @@ Three things hold the line today, and all three keep working whether or not seal
 
 - **The reserved bucket.** `RUSTFS_META_BUCKET` is `.rustfs.sys`; `is_reserved_or_invalid_bucket` keeps it off the S3 surface, and the admin inspect archive in `rustfs/src/admin/handlers/inspect_archive.rs` runs its request through a strict bucket-name check that a dot-prefixed reserved name does not pass.
 - **Admin authorization** on every route that can read or write one of the three configurations.
-- **Redaction on every read path.** `BucketTarget::redacted_credentials` and the `Debug` for `Credentials` in `crates/ecstore/src/bucket/target/bucket_target.rs`, used by the remote-target listing in `rustfs/src/admin/handlers/replication.rs` and by the bucket-metadata export in `rustfs/src/admin/handlers/bucket_meta.rs`; `TierConfig::redacted` in `crates/ecstore/src/services/tier/tier_config.rs`, which is also what that type's `Clone` and `Debug` do; and `SourceCredentials::redacted` in `rustfs/src/on_demand_migration/config.rs`, used by `rustfs/src/admin/handlers/on_demand_migration.rs`.
+- **Redaction on every read path.** `BucketTarget::redacted_credentials` and the `Debug` for `Credentials` in `crates/ecstore/src/bucket/target/bucket_target.rs`, used by the remote-target listing in `rustfs/src/admin/handlers/replication.rs` and by the bucket-metadata export in `rustfs/src/admin/handlers/bucket_meta.rs`; `TierConfig::redacted` in `crates/ecstore/src/services/tier/tier_config.rs`, which is also what that type's `Clone` and `Debug` do; and `SourceCredentials::redacted` in `crates/ecstore/src/bucket/on_demand_migration/config.rs`, used by `rustfs/src/admin/handlers/on_demand_migration.rs`.
 
 So no API returns a stored secret. The bytes are reachable by reading the drives, and that is the boundary sealing is proposed to move.
 
@@ -74,7 +74,7 @@ The envelope deliberately does **not** carry its own scope. A scope read out of
 
 ## Why a hook instead of a dependency
 
-`crates/ecstore/Cargo.toml` has no `rustfs-kms` dependency, and adding one would invert the crate layering described in [crate-boundaries.md](crate-boundaries.md). The established shape is an `OnceLock` hook that ECStore defines and the binary installs at startup, as `EVENT_DISPATCH_HOOK` in `crates/ecstore/src/services/event_notification.rs` and `BUCKET_CONFIG_PUBLISH_HOOK` in `crates/ecstore/src/bucket/metadata_sys.rs` already do. `install_credential_sealer` follows it, and the binary supplies an implementation backed by `crates/kms/src/service_manager.rs`.
+`crates/ecstore/Cargo.toml` has no `rustfs-kms` dependency, and adding one would invert the crate layering described in [crate-boundaries.md](crate-boundaries.md). The established shape is an `OnceLock` hook that ECStore defines and the binary installs at startup, as `EVENT_DISPATCH_HOOK` in `crates/ecstore/src/services/event_notification.rs` and `ON_DEMAND_MIGRATION_CONFIG_HOOK` in `crates/ecstore/src/bucket/on_demand_migration/config.rs` already do. `install_credential_sealer` follows it, and the binary supplies an implementation backed by `crates/kms/src/service_manager.rs`.
 
 ## Compatibility, per store, because the three differ
 

docs/operations/bucket-metadata-recovery.md

@@ -1,22 +0,0 @@
-# Bucket metadata diagnostics and recovery
-
-`GET /rustfs/admin/v3/export-bucket-metadata` keeps its strict behavior: an unreadable configuration fails the export. The optional `bucket` query selects one bucket; omitting it selects all buckets.
-
-To inspect readable configurations while identifying failures, use the same authenticated endpoint with `?diagnostic=true`. This requires the existing `ExportBucketMetadataAction` permission. A successful response has:
-
-- Filename `bucket-meta-diagnostic.zip` and header `x-rustfs-bucket-metadata-export: diagnostic`.
-- Readable entries under `_diagnostic/<bucket>/<config>`; target credentials remain redacted.
-- `_diagnostic-manifest.json`, containing `version: 1`, `mode: "diagnostic"`, `complete`, and an `errors` array. Each error identifies `bucket`, `config`, and the fixed code `configuration_unavailable`. The archive excludes unreadable payloads and parser error details.
-
-`complete` reports whether all supported configuration reads succeeded. A diagnostic archive is never a restorable backup, including when `complete` is true. Import rejects the manifest or reserved directory before any bucket creation or configuration write. The reserved directory is not a valid bucket name, so older importers cannot restore diagnostic entries as ordinary bucket configurations.
-
-## Recover unreadable replication targets
-
-RustFS currently accepts the documented `{"targets": [...]}` object format. It cannot decrypt MinIO KMS-encrypted target metadata. Unreadable target payloads remain failures instead of being interpreted as an empty target set; diagnostic export and replacement import do not add MinIO KMS decryption support.
-
-1. Inspect the diagnostic manifest to identify affected buckets. Preserve a separate backup of the original source configuration and any credentials needed for recovery.
-2. Prepare a ZIP containing `<bucket>/bucket-targets.json` with a valid RustFS replacement, whose top-level shape is `{"targets": [...]}`. Supply the intended target settings and credentials; exported credentials are redacted. Use `{"targets": []}` only when intentionally clearing all targets, and reconcile any replication rules that reference removed targets.
-3. Submit the ZIP to the existing authenticated `PUT /rustfs/admin/v3/import-bucket-metadata` endpoint with `ImportBucketMetadataAction` permission. Import validates the replacement and persists it against the bucket incarnation; it does not need to parse the old target payload successfully.
-4. Verify target listing and the intended replication configuration. Retry the ordinary strict metadata export to confirm the unreadable configuration no longer blocks it.
-
-Do not submit the diagnostic archive itself to the import endpoint. Copy only reviewed replacement entries into an ordinary import archive.

docs/operations/on-demand-migration.md

@@ -1,26 +1,12 @@
 # On-Demand Migration
 
 **Use this when:** you are moving an existing S3-compatible bucket into RustFS without a stop-the-world copy, or you are debugging a bucket that serves reads from an external source (424 `SourceUnavailable`, an open circuit breaker, missing pulled objects, a source 403).
-**Source of truth:** `rustfs/src/on_demand_migration/` (`config.rs` for the wire model and its bounds, `sys.rs` for the per-node runtime, `source_client.rs` for the outbound client, `pull.rs` for the write-back pipeline, `breaker.rs` and `negative_cache.rs` for the protections), `rustfs/src/app/object/get.rs` and `head.rs` for the read paths, `rustfs/src/app/object/on_demand_migration_put.rs` for the local write, `rustfs/src/admin/handlers/on_demand_migration.rs` for the admin API, and `crates/obs/src/metrics/schema/on_demand_migration.rs` for the metric contract.
+**Source of truth:** `crates/ecstore/src/bucket/on_demand_migration/` (`config.rs` for the wire model and its bounds, `sys.rs` for the per-node runtime, `source_client.rs` for the outbound client, `pull.rs` for the write-back pipeline, `breaker.rs` and `negative_cache.rs` for the protections), `rustfs/src/app/object/get.rs` and `head.rs` for the read paths, `rustfs/src/app/object/on_demand_migration_put.rs` for the local write, `rustfs/src/admin/handlers/on_demand_migration.rs` for the admin API, and `crates/obs/src/metrics/schema/on_demand_migration.rs` for the metric contract.
 
 On-Demand Migration (ODM) attaches an external S3-compatible **source bucket** to a local RustFS bucket. When a client GETs a key that does not exist locally, RustFS fetches it from the source, streams it to the client, and stores it locally in the same pass; every later read is served locally. It is a pull-style, lazy migration path — the RustFS equivalent of Cloudflare R2 Sippy, Tigris shadow buckets, and Alibaba Cloud OSS / Tencent COS mirror-back-to-origin.
 
 The module is on by default (rustfs/backlog#2163); set `RUSTFS_ON_DEMAND_MIGRATION_ENABLED=false` on every node to turn it off (`rustfs/src/module_switches.rs`). With the switch off, the runtime never intervenes on a read and the admin `PUT` route refuses with `OnDemandMigrationDisabled`. Reads of the configuration and of the status endpoint keep working while the switch is off, so a disabled deployment can still be inspected. The switch only decides whether the module may act at all: a bucket with no `on-demand-migration.json` is never resolved by the runtime and makes no source call, so turning the module on changes nothing for buckets you have not configured.
 
-## Upgrade and rollback compatibility
-
-ODM configuration is stored in two additional keys in the existing bucket metadata map. The metadata format version remains `1` for MinIO compatibility. RustFS `1.0.0-rc.5` only re-encodes its 44 known keys: a bucket configuration write through an rc.5 node discards the ODM configuration and timestamp, even if another node originally wrote them. Restarting a newer binary cannot recover the discarded values. This also means ODM is not supported during a rolling upgrade that still allows rc.5 nodes to write bucket metadata.
-
-Upgrade every node before enabling ODM. Before any rollback to rc.5, stop new migration work, retain a secure copy of the original full configuration and credentials, and disable ODM on every bucket and node. The redacted configuration GET and metadata export are not credential backups. Objects still present only at the source cannot be read through RustFS while ODM is disabled or rc.5 is running; finish migration first, redirect those reads to the source, or plan a maintenance window. After all nodes return to a compatible release, reapply and validate the saved configuration; already stored local objects remain local. Turning the global module switch off alone does not make an old metadata writer preserve these keys.
-
-The ignored `upgrade_compatibility_test::rc5_rollback_requires_restoring_odm_configuration` test pins release commit `40a2470feb567201165a5b809b7598bb4b1f68f5`, restarts against the same data directory, writes bucket tags through rc.5, and verifies configuration recovery after returning to the current binary. Set `RUSTFS_UPGRADE_SOURCE_BINARY` to that release's executable and run `cargo test -p e2e_test rc5_rollback_requires_restoring_odm_configuration -- --ignored --test-threads=1`. The test records a known old-writer limitation; it does not certify mixed-version ODM operation.
-
-## Optional Google dependencies
-
-The default and `full` server builds include the `gcs` Cargo feature to preserve native GCS migration and existing GCS tier support. For a server without Google SDK dependencies, build with `cargo build -p rustfs --no-default-features --features ftps,webdav`. Add `gcs` to that feature list to restore native GCS support. The ECStore library has no default Google dependency; library users that need GCS tiers must enable its `gcs` feature.
-
-Both builds can read, redact and preserve GCS configuration. A build without `gcs` rejects native ODM client construction with `OnDemandMigrationBackendNotCompiled` (HTTP 501); persisted native sources report an unavailable client. GCS tier initialization returns `XRustFSAdminTierTypeUnsupported` (HTTP 501). Do not deploy that build to a cluster with GCS tiers containing transitioned objects: the configuration remains intact, but reading their remote data requires a GCS-capable binary. The `gcs` provider using HMAC credentials and the S3 interoperability API remains available in every build; only `gcs_native` and native GCS tier clients need the feature.
-
 ## List continuation token rollout
 
 `RUSTFS_ON_DEMAND_MIGRATION_LIST_V2_TOKENS` defaults to `false`; unset or invalid boolean values also keep it off. It controls only whether a v1 listing may first issue a v2 continuation token after an empty truncated merged page. Every node with this reader support accepts existing v2 tokens and continues their budget even with the switch off. Ordinary pages that consume an object or common prefix retain the original v1 token shape.
@@ -111,7 +97,7 @@ Read-through only migrates what clients touch. The background backfill job walks
 
 ## Configuration reference
 
-The persisted blob is `on-demand-migration.json` in the bucket's metadata. Unknown fields are rejected rather than dropped, so a config written by a newer build fails loudly on an older one. Every default and bound below comes from `rustfs/src/on_demand_migration/config.rs`.
+The persisted blob is `on-demand-migration.json` in the bucket's metadata. Unknown fields are rejected rather than dropped, so a config written by a newer build fails loudly on an older one. Every default and bound below comes from `crates/ecstore/src/bucket/on_demand_migration/config.rs`.
 
 | Field | Type | Default | Bounds / rules |
 |---|---|---|---|
@@ -168,7 +154,7 @@ Validation also rejects two shapes outright: a source whose endpoint and bucket
 | `azure` | Optional; derived as `https://<account>.blob.core.windows.net` | Native Blob REST, not S3 | Unused; write `auto` | Needs `source.azure`; the container is `source.bucket`. Reads need `Read` on the blob and `List` on the container, plus `Tags` when `policy.copy_tags` is on | None yet: no interop job covers Azure |
 | `gcs_native` | Optional; derived as `https://storage.googleapis.com` | Native GCS API, not S3 | Unused; write `auto` | Needs `source.gcs`. Reads use the XML API for objects and `objects.list` for listings, both with an OAuth token minted from the service-account key; the key needs `storage.objects.get` and `storage.objects.list` | None yet: no interop job covers native GCS |
 
-Every backend answers the same trait contract, pinned by `backend_contract.rs` in `rustfs/src/on_demand_migration/`, and the three differences that contract allows are the ones documented here.
+Every backend answers the same trait contract, pinned by `backend_contract.rs` in `crates/ecstore/src/bucket/on_demand_migration/`, and the three differences that contract allows are the ones documented here.
 
 `azure` differs in two of them. Its ETag is a concurrency token rather than a digest of the bytes, so it is stored as `odm-source-etag` provenance and never used as the expected MD5 of a pulled object — the write-back integrity check falls back to the local digest. And its listing paginates only with an opaque marker: there is no "start after this key" form, so a caller that asks for one gets `Unsupported` instead of a listing that silently starts over.
 

docs/operations/scanner-benchmark-runbook.md

@@ -34,6 +34,149 @@ The `scanner` and `heal` subsystems are served by `GetConfigKVHandler` (`rustfs/
 
 ## Test Matrix
 
+### Formal Scanner/Heal ABBA
+
+The `--abba` mode runs five independent scenario cells: `cold-hot`, `fresh-hot`,
+`multi-hot-new`, `running-heal`, and `mrf-replay`. Each scenario runs at least
+three A1/B1/B2/A2 groups for both baseline/candidate with background work on,
+and candidate-only background off/on. A measured leg lasts at least 900
+seconds; the minimum matrix contains 120 legs (30 hours before setup/oracles).
+The existing `performance-ab.yml` supplies the pattern for immutable build
+provenance and failure propagation, but its short Warp workload is not this
+scanner gate. No scheduled workflow starts this matrix automatically.
+
+```bash
+scripts/run_scanner_validation_harness.sh --abba \
+  --manifest scanner-abba.json --adapter /path/to/isolated-deployment-adapter \
+  --out-dir /path/to/new-artifacts --data-root /path/to/new-test-data
+```
+
+Both roots must be new and non-overlapping. Every leg receives a unique data
+directory. The runner checks disk capacity before each leg, never removes data,
+and stops the adapter after success or failure. Retain raw artifacts and inspect
+task ownership before removing any test data. The operator must reserve the
+target machines and map the assigned directory to separate data paths on every
+node; the runner cannot prove remote isolation from local path names.
+
+The manifest has the following JSON contract (all fields are required):
+
+| Field | Value |
+|---|---|
+| `schema`, `evidence` | `1`, and `measured` or `synthetic`. |
+| `rounds`, `duration_seconds`, `min_free_bytes` | 3..10 groups, 900..86400 seconds for measured runs, and the independently estimated free-space reservation in bytes. Synthetic runs may use 1 second. |
+| `baseline`, `candidate` | Each contains executable `binary`, full 40-character `revision`, and verified `sha256`. The runner rehashes binaries before every leg. |
+| `fixed` | `config_sha256`, `dataset_sha256`, `release_flags`, `durability`, `disk_type`, `cache_state`, `load_command`, `resource_isolation`, `topology` (`EC8+4`), and positive `offered_load_ops`. Hashes use 64 lowercase hexadecimal characters. |
+| `oracles` | A map with all five scenario names. Each value contains positive integer `objects`, `versions`, `bytes`, and `sha256` of the independently prepared canonical object/version/content manifest. |
+| `expected_healed_objects` | A map with all five scenario names and independently seeded repair counts. Running-heal and MRF-replay require a positive count. |
+
+Record exact build flags and effective durability settings, not just defaults.
+Use deterministic workload seeds so every isolated leg has the same expected
+object/version/content result. Fix the foreground arrival rate (offered load),
+cache preparation procedure, configuration, and hardware across every leg.
+Do not include credentials in the manifest, adapter output, or saved commands;
+the collector reads `RUSTFS_ACCESS_KEY` and `RUSTFS_SECRET_KEY` from its environment.
+
+#### Deployment Adapter Contract
+
+The runner invokes an executable as `adapter ACTION request.json response.json`
+with no shell evaluation. Actions are separate processes: `prepare`, `measure`,
+`oracle`, and `stop`. Every action must return zero and write a JSON object of
+at most 1 MiB. Logs are kept separately and require an operator-managed disk
+quota. Missing output, timeout, nonzero exit, unknown/missing metrics, zero
+samples, and request errors fail the run. Adapters must terminate their own
+children on failure and `stop` must be idempotent even after partial preparation.
+The runner keeps its session leader unreaped while stopping a failed command
+or collector: it sends TERM, allows the existing ten-second grace period, then
+kills the remaining process group before reaping. This prevents a parent exit
+from hiding live descendants or allowing the group ID to be reused before its
+last signal. A successful `prepare` preserves adapter-owned services until
+`stop`; services that leave the command's process group remain the adapter's
+cleanup responsibility.
+
+The request contains the fixed manifest fields, selected build, scenario, round,
+leg, comparison (`build` or `background`), background mode (`on` or `off`),
+duration, unique `data_dir`, expected object oracle, and expected repair count.
+Adapter responsibilities:
+
+1. `prepare` deploys the selected binary into an authorized isolated topology,
+   checks actual binary/config/durability, initializes deterministic scenario
+   data and the requested cache state, and returns `{"ready": true}`. For measured
+   runs it also returns `collector` with exactly `alias`, `endpoint`, and
+   comma-separated `metrics_endpoints`; the runner starts the existing scanner
+   collector at 60-second cadence while `measure` runs.
+2. `measure` maintains the fixed offered load for the entire requested duration.
+   `cold-hot` retains cold buckets while mutating a hot bucket; `fresh-hot`
+   creates a bucket after scanner startup; `multi-hot-new` combines several hot
+   buckets with a newly created bucket; `running-heal` applies foreground load
+   during active repair; `mrf-replay` replays independently seeded durable repair
+   work. Capture same-window status for bucket-freshness issue #7108. Actual
+   fault injection and dataset generation belong to the reviewed adapter.
+3. `oracle` independently enumerates all objects and versions, reads and checks
+   their complete bytes, and verifies repairs. Return `complete: true`, integer
+   `errors: 0`, and `actual` matching the manifest's expected oracle. Never copy
+   expected values into a measured oracle or infer completion from empty queues.
+4. `stop` stops task-owned workload/server processes and returns `stopped: true`.
+   Preserve data and artifacts for diagnosis. An adapter may restore previous
+   settings but must not delete arbitrary paths or stop unrelated deployments.
+
+The `measure` response echoes the observed `evidence`, `fixed`, `build`,
+`data_dir`, and `background`, plus `sample_count` (1..3600), `elapsed_seconds`,
+and `metrics`. All metrics must be finite nonnegative numbers: `p99_ms`,
+`throughput_ops`, `rss_bytes`, `cpu_seconds`, `iops`, `rpc_count`,
+`cache_clone_bytes`, `encode_bytes`, `save_bytes`, `oldest_age_seconds`,
+`walk_objects`, `cold_walk_objects`, `healed_objects`, `errors`, and `requests`.
+Requests, throughput, and p99 must be positive; errors must be zero. Repair
+counts must match the manifest when background work is on. Keep underlying
+request samples, counter reset checks, profiler captures, and per-node telemetry
+in the cell artifact directory; aggregate values alone do not establish their
+measurement provenance. Missing production instrumentation is a pending gate,
+not permission to report a fabricated zero.
+
+For P2, `measure.convergence` contains booleans `writes_stopped`,
+`last_mutation_observed`, `first_complete_publication`; numeric
+`last_mutation_time`, `last_mutation_observed_time`, `writes_stopped_time`, `window_start`, `window_end`,
+`budget_available_seconds`, `walk_objects`, and `full_walk_objects`. Times use
+one monotonic clock. The window starts after writes stop and the final mutation
+is observed, and ends at the first complete publication. The reference is an
+independent full walk of the same static namespace. Record available budget
+seconds to interpret elapsed time. During continuing writes, omit this proof
+and report useful-work ratio and justified invalidation/re-scan work separately;
+the runner reports P2 pending and does not impose a fixed cumulative walk bound.
+
+The nightly heal workflow clones **`rustfs/auto-testing`** separately and invokes
+`auto-testing/rustfs_heal_test.sh`; that script is not a local `scripts/test`
+entry point. If an adapter uses it, record and verify the external checkout's
+owner and full commit before use. The current workflow clones the default branch,
+so its contents must not be attributed to a RustFS source SHA.
+
+#### Evidence Gates
+
+`report.json` records each group's verdict and the raw responses remain in their
+cell directories. Candidate/build p99 regression must be at most 5% and
+throughput loss at most 3%; candidate background on/off limits are 10% and 5%.
+P1 requires cold-hot walk reduction of at least the baseline cold-walk share
+times 80%, rather than a fixed 80% reduction for every workload. P2 requires
+candidate post-stop work at most 1.2 times the independent full-walk reference.
+Missing candidate convergence proof yields `inconclusive`. A2/A1 or B2/B1 p99
+or throughput drift above 5% also yields `inconclusive`, with exit code 3.
+Correctness errors and non-noisy performance regressions exit 1. Every group
+must pass; a favorable median cannot hide a failing group.
+
+Synthetic success is explicitly `synthetic_validated`, with `performance:
+pending`. It validates orchestration and gate logic only. It proves no runtime,
+distributed, crash, mixed-version, or performance behavior and cannot close the
+performance acceptance gate. Run the fake-adapter self-tests with:
+
+```bash
+scripts/test_scanner_validation_harness.sh
+```
+
+They cover the complete 120-cell schedule, data isolation, missing builds and
+oracles, zero samples/requests, swallowed request errors, offered-load drift,
+incomplete repairs, missing metrics, noise, and P1/P2/p99 regressions. A real
+deployment adapter and actual ABBA artifacts remain required before any measured
+performance or release claim.
+
 Collect at least two runs on the same RustFS commit and the same workload. Keep hardware, commit, object count, object size, bucket count, scanner-enabled state, and foreground workload constant between runs.
 
 | Run | Purpose | Example scanner settings |

docs/testing/ci-gates.md

@@ -49,7 +49,7 @@ Promotion rule: never promote a report-only lane to required from one green run.
 | PR touching `paths` in `fuzz.yml` | `Build Fuzz Harness`, `Smoke / <target>` | `fuzz.yml` `fuzz-build`, `pr-fuzz-smoke` | Report-only | `MAX_TOTAL_TIME=60 ./scripts/fuzz/run.sh` |
 | PR touching `paths` in `windows-filesystem.yml` | `Rename Safety` | `windows-filesystem.yml` `rename-safety` | Report-only | the `cargo test -p rustfs-ecstore --lib <filter>` commands in the job, on Windows |
 | PR touching `paths` in `coverage.yml` | `Workspace line coverage` | `coverage.yml` `coverage` | Report-only | `make coverage`; `python3 scripts/check_security_coverage.py target/llvm-cov/coverage.json` |
-| PR touching `paths` in `e2e-upgrade.yml` | `Direct upgrade from the previous release`, `Mixed-version rolling upgrade from the previous release`, `Bucket configuration survives the upgrade`, `Rollback reads current bucket metadata` | `e2e-upgrade.yml` `upgrade` matrix | Report-only | the `cargo test --locked -p e2e_test` command in the job with `RUSTFS_UPGRADE_SOURCE_BINARY` pointing at the pinned previous release (`UPGRADE_SOURCE_VERSION`) |
+| PR touching `paths` in `e2e-upgrade.yml` | `Direct upgrade from rc.2` | `e2e-upgrade.yml` `direct-upgrade` | Report-only | the `cargo test --locked -p e2e_test` command in the job with `RUSTFS_UPGRADE_SOURCE_BINARY` pointing at the pinned previous release |
 | PR touching `paths` in `oidc-keycloak.yml` | `OIDC Keycloak live gate` | `oidc-keycloak.yml` `oidc-keycloak-live` | Report-only | `cargo build --locked -p rustfs --bin rustfs`, then `bash scripts/test/oidc_keycloak_live.sh ./target/debug/rustfs` |
 | PR touching `paths` in `targets-integration.yml` | `PostgreSQL, MySQL, AMQP, and NATS` | `targets-integration.yml` `targets-live` | Report-only | start the containers as in the job, export the `RUSTFS_TEST_*` DSNs, then the job's `cargo test --locked -p rustfs-targets --test <name> -- --ignored --test-threads=1` commands |
 | PR limited to main-CI-excluded paths | `Quick Checks`, `Test and Lint` | `ci-docs-only.yml` `quick-checks`, `test-and-lint` | Required | `git diff --check`; `make doc-paths-check`; `scripts/check_no_planning_docs.sh` |
@@ -84,7 +84,7 @@ Scheduled lanes never block a PR. Their workflow-local gate fails the run, sched
 | `mint.yml` (weekly) | `mint` | report-only by design; per-suite PASS/FAIL/NA and raw `log.json` | yes | pinned Docker sequence in the workflow |
 | `coverage.yml` (weekly) | `coverage` | report-only trend; lcov and JSON artifact | yes | `make coverage` |
 | `runner-hygiene.yml` (monthly) | `check-ephemerality` | runner ephemerality | yes | dispatch |
-| `e2e-upgrade.yml` (weekly) | `upgrade` (4-case matrix) | upgrade and rollback gate; server logs | no | see the PR row |
+| `e2e-upgrade.yml` (weekly) | `direct-upgrade` | upgrade gate; server logs | no | see the PR row |
 | `oidc-keycloak.yml` (weekly) | `oidc-keycloak-live` | live OIDC gate | no | see the PR row |
 | `targets-integration.yml` (nightly) | `targets-live` | live target gate; container logs | no | see the PR row |
 | `scheduled-validation-freshness.yml` (nightly) | `check-freshness` | fails on a never-created or stale schedule | n/a | dispatch |
@@ -125,3 +125,108 @@ The manifest records a minimum set of invariants: write quorum, metadata rollbac
 The checked-in MinIO corpus is pinned by file SHA256 and its documented source release. The static wiring guard and the CI selection check both reject missing or changed fixtures. These are metadata fixtures, not a legacy shard-body corpus or proof of crash durability. Optional `legacy_bitrot_read_test` runs may still skip when their external corpus is absent; they do not satisfy a required compatibility lane. Real encrypted fixture reads remain in `minio-interop.yml`, and multi-node fault schedules remain in the existing nightly cluster lane. In-process reopen tests do not establish power-loss durability.
 
 Run `python3 scripts/check_test_wiring.py --self-test` to exercise the negative cases: removed/ignored/filtered tests, malformed listing, absent fixtures, and wrong fixture hashes. Do not update hashes merely to silence the guard; a fixture change needs source/provenance and compatibility review.
+## Scanner/Heal Evidence Receipts
+
+The existing `scripts/check_test_wiring.py` also validates Scanner/Heal case
+evidence registered in `.config/scanner-heal-required-tests.json`. It records
+already-built binaries and checks existing nextest output; it does not build,
+run tests, deploy servers, inject faults, or start another CI lane.
+
+The initial case is `background-target-restart`, emitted by
+`heal_erasure_disk_rebuild_test::tests::test_cluster_root_heal_recovers_remote_shards_after_background_target_restart`.
+That test already runs in `e2e-nightly`. When `RUSTFS_SCANNER_HEAL_RUN_DIR` is set,
+it checks the actual server and test-executable hashes against `run.json`, pins
+the same server binary for all node starts, and writes its oracle only after
+the real assertions pass. The artifact contains the actual pre/post target
+PIDs, per-node S3 listings, expected and downloaded complete-body hashes/lengths,
+and target-disk `VersionShardCensus` fingerprints. Existing baseline objects
+must match their pre-fault physical manifests; the object created during the
+outage has no pre-fault target shard and is checked for complete physical parts
+and exact S3 content.
+
+This case is a **four-node, one-drive-per-node process-restart test**. It is not
+power-loss validation, a 3x4 EC8+4 experiment, an all-version inventory, or proof
+of scanner enumeration, exact MRF disposition, legacy migration, or rollback.
+The registry keeps all G01-G14/P1-P4 and R-E/R-D/R-L release requirements pending
+until their actual feature-specific oracles and required topologies exist.
+Missing cases cannot be supplied by synthetic W20 results. W20's bounded JSON
+and file-hash helpers are reused; its ABBA performance contracts remain in
+`docs/operations/scanner-benchmark-runbook.md`.
+
+### Recording One Case
+
+Use a committed source tree, independently built current binaries, sufficient
+free disk space, and a task-owned artifact directory that does not yet exist.
+Set `SERVER_BINARY` and `TEST_BINARY` to those exact executable paths. The begin
+command requires the server's embedded `--version` commit to match the clean
+checkout and its embedded Git status to be clean. The E2E crate's build script
+embeds its build-time Git revision/dirty state, lockfile Git blob, enabled crate
+features, target, profile and encoded Rust flags. It tracks the crate/dependency
+trees, Cargo inputs and Git HEAD/ref/index, including `common.rs` restart logic.
+The producer checks this compiled identity against the receipt; it does not
+copy a current source revision into an older test binary's identity. The E2E
+uses its existing temporary cluster directories and cleanup. `CARGO_TARGET_DIR`
+controls compilation output; nextest's default report store remains the
+workspace's `target/nextest`. Execute the existing selected case as follows:
+
+```bash
+CASE=background-target-restart
+FILTER='test(test_cluster_root_heal_recovers_remote_shards_after_background_target_restart)'
+RUN_DIR="$PWD/artifacts/scanner-heal-run"
+export RUSTFS_E2E_EXPECTED_FEATURES=default
+scripts/python_bin.sh scripts/check_test_wiring.py \
+  --begin-scanner-heal "$RUN_DIR" "$SERVER_BINARY" "$TEST_BINARY"
+export RUSTFS_SCANNER_HEAL_RUN_DIR="$RUN_DIR"
+export CARGO_BIN_EXE_rustfs="$SERVER_BINARY"
+cargo nextest list --profile e2e-nightly -p e2e_test -E "$FILTER" \
+  --message-format json > "$RUN_DIR/listing.json"
+rm -f target/nextest/e2e-nightly/junit.xml
+set +e
+cargo nextest run --profile e2e-nightly -p e2e_test -E "$FILTER"
+test_exit=$?
+set -e
+cp target/nextest/e2e-nightly/junit.xml "$RUN_DIR/junit.xml"
+scripts/python_bin.sh scripts/check_test_wiring.py --finish-scanner-heal "$RUN_DIR" "$test_exit"
+scripts/python_bin.sh scripts/check_test_wiring.py --check-scanner-heal "$RUN_DIR" "$CASE"
+```
+
+Set `RUSTFS_E2E_EXPECTED_FEATURES` to the actual intended e2e crate feature set,
+including `default` for a default-feature build, comma-separated for extra
+features, or empty for `--no-default-features`. It is mandatory when beginning
+a run. Crate features are distinct from the spawned server's build features.
+
+Do not replace a nonzero command exit with zero. Missing JUnit or an oracle
+emission failure also fails acceptance. Each retry needs a new run directory;
+the producer refuses to overwrite an existing oracle. Keep failed-run logs and
+artifacts. The receipt pins source revision, actual binary hashes, run identity,
+start/finish times, and the artifact hashes. `listing.json`, `junit.xml`, and
+each oracle are limited to 1 MiB; object evidence has the fixture's 9..65 object
+bound. Credentials are not included in the receipt.
+
+The checker binds nextest's flattened suite `binary-id`/`binary-path` to the
+actual test executable and requires the JUnit testcase's embedded execution
+timestamp to fall inside the receipt window (with millisecond precision).
+Copying an old JUnit file and refreshing its mtime does not make it new evidence.
+Schema versions, topology counts, PIDs, EC geometry and shard indices require
+actual integers: booleans and fractional values are rejected, and an index must
+fit the physical data-plus-parity geometry.
+
+The checker rejects unselected/ignored tests, zero/duplicate JUnit cases,
+failures, skipped tests, retry/flaky records, stale or changed artifacts,
+different builds or run IDs, unchanged process IDs, wrong topology, missing
+shard parts, and mismatched S3 content/listings. The raw oracle JSON is emitted
+by the real E2E producer, not accepted from an adapter copying expectations.
+
+`--check-scanner-heal "$RUN_DIR" release` checks available case evidence and
+returns nonzero for every pending release requirement. A focused case pass
+does not approve release. In particular, R-E requires fixed-budget real
+restarts without an unbudgeted final sweep, R-D requires the full
+manager/event/ledger disposition chain, and R-L requires source-conflict and
+crash/retirement evidence. Reader-only or unit fixtures cannot substitute for
+these. The external `rustfs/auto-testing` functional workflows propagate suite
+failures. Their workflow status does not establish this registry's required
+case coverage, build provenance, or object-level oracles.
+
+Run parser/receipt regressions with
+`scripts/python_bin.sh scripts/check_test_wiring.py --self-test`. Those fixtures
+validate the checker only and produce no runtime or performance evidence.

rustfs/Cargo.toml

@@ -57,8 +57,7 @@ name = "swift_object_integration_test"
 required-features = ["swift"]
 
 [features]
-default = ["ftps", "webdav", "gcs"]
-gcs = ["rustfs-ecstore/gcs", "dep:google-cloud-auth"]
+default = ["ftps", "webdav"]
 metrics-gpu = ["rustfs-obs/gpu"]
 ftps = ["rustfs-protocols/ftps"]
 swift = ["rustfs-protocols/swift"]
@@ -67,7 +66,7 @@ sftp = ["rustfs-protocols/sftp"]
 license = []
 io-scheduler-debug = []  # Enable debug information in I/O scheduler
 tracing-chunk-debug = []  # Enable per-chunk tracing in data plane (high noise, for debugging only)
-full = ["metrics-gpu", "ftps", "swift", "webdav", "sftp", "pyroscope", "gcs"]
+full = ["metrics-gpu", "ftps", "swift", "webdav", "sftp", "pyroscope"]
 e2e-test-hooks = []
 # Shortens Connect credentials only in debug E2E builds.
 connect-e2e-short-credentials = []
@@ -276,7 +275,6 @@ rcgen = { workspace = true }
 # Async Runtime and Networking
 async-trait = { workspace = true }
 axum.workspace = true
-faster-hex.workspace = true
 futures.workspace = true
 futures-lite.workspace = true
 futures-util.workspace = true
@@ -289,11 +287,6 @@ reqwest = { workspace = true, features = ["json", "stream"] }
 socket2 = { workspace = true, features = ["all"] }
 tokio = { workspace = true, features = ["rt-multi-thread", "macros", "net", "signal", "process", "io-util", "fs"] }
 tokio-rustls = { workspace = true, default-features = false, features = ["logging", "tls12", "aws-lc-rs"] }
-aws-smithy-runtime-api = { workspace = true, features = ["http-1x"] }
-aws-smithy-types = { workspace = true }
-google-cloud-auth = { workspace = true, optional = true }
-moka = { workspace = true, features = ["sync"] }
-xxhash-rust = { workspace = true, features = ["xxh3"] }
 aws-sdk-s3 = { workspace = true, default-features = false, features = ["sigv4a", "default-https-client", "rt-tokio"] }
 tokio-stream.workspace = true
 tokio-util = { workspace = true, features = ["io", "compat", "time"] }

rustfs/src/admin/handlers/bucket_meta.rs

@@ -64,9 +64,6 @@ use time::OffsetDateTime;
 use tracing::warn;
 use zip::{ZipArchive, ZipWriter, write::SimpleFileOptions};
 
-const DIAGNOSTIC_EXPORT_PREFIX: &str = "_diagnostic";
-const DIAGNOSTIC_EXPORT_MANIFEST: &str = "_diagnostic-manifest.json";
-
 const LOG_COMPONENT_ADMIN: &str = "admin";
 const LOG_SUBSYSTEM_BUCKET_META: &str = "bucket_meta";
 const EVENT_ADMIN_BUCKET_META_STATE: &str = "admin_bucket_meta_state";
@@ -100,198 +97,9 @@ fn checked_versioning_xml(validated: &VersioningConfiguration, raw: Vec<u8>) ->
     checked_raw_xml(validated, raw, deserialize::<VersioningConfiguration>)
 }
 
-async fn exported_bucket_config(bucket: &str, conf: &str) -> S3Result<Option<Vec<u8>>> {
-    match conf {
-        BUCKET_POLICY_CONFIG => {
-            let config: BucketPolicy = match metadata_sys::get_bucket_policy(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "failed to load bucket metadata: {e}"));
-                }
-            };
-            let config_json =
-                serde_json::to_vec(&config).map_err(|e| s3_error!(InternalError, "failed to serialize config: {e}"))?;
-            Ok(Some(config_json))
-        }
-        BUCKET_NOTIFICATION_CONFIG => {
-            let config: s3s::dto::NotificationConfiguration = match metadata_sys::get_notification_config(bucket).await {
-                Ok(Some(res)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
-                }
-                Ok(None) => return Ok(None),
-            };
-
-            let raw_config = metadata_sys::get(bucket)
-                .await
-                .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
-                .notification_config_xml
-                .clone();
-            let config_xml = checked_raw_xml(&config, raw_config, deserialize::<s3s::dto::NotificationConfiguration>)?;
-
-            Ok(Some(config_xml))
-        }
-        BUCKET_LIFECYCLE_CONFIG => {
-            let config: BucketLifecycleConfiguration = match metadata_sys::get_lifecycle_config(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "failed to load bucket metadata: {e}"));
-                }
-            };
-            let raw_config = metadata_sys::get(bucket)
-                .await
-                .map_err(|e| export_internal_error(format!("failed to load bucket metadata: {e}")))?
-                .lifecycle_config_xml
-                .clone();
-            let config_xml = checked_raw_xml(&config, raw_config, deserialize::<BucketLifecycleConfiguration>)?;
-
-            Ok(Some(config_xml))
-        }
-        BUCKET_TAGGING_CONFIG => {
-            let config: Tagging = match metadata_sys::get_tagging_config(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "failed to load bucket metadata: {e}"));
-                }
-            };
-            let raw_config = metadata_sys::get(bucket)
-                .await
-                .map_err(|e| export_internal_error(format!("failed to load bucket metadata: {e}")))?
-                .tagging_config_xml
-                .clone();
-            let config_xml = checked_raw_xml(&config, raw_config, deserialize::<Tagging>)?;
-
-            Ok(Some(config_xml))
-        }
-        BUCKET_QUOTA_CONFIG_FILE => {
-            let config: BucketQuota = match metadata_sys::get_quota_config(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
-                }
-            };
-            let config_json =
-                serde_json::to_vec(&config).map_err(|e| s3_error!(InternalError, "serialize config failed: {e}"))?;
-
-            Ok(Some(config_json))
-        }
-        OBJECT_LOCK_CONFIG => {
-            let config = match metadata_sys::get_object_lock_config(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
-                }
-            };
-            let raw_config = metadata_sys::get(bucket)
-                .await
-                .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
-                .object_lock_config_xml
-                .clone();
-            let config_xml = checked_raw_xml(&config, raw_config, deserialize::<ObjectLockConfiguration>)?;
-
-            Ok(Some(config_xml))
-        }
-        BUCKET_SSECONFIG => {
-            let config = match metadata_sys::get_sse_config(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
-                }
-            };
-            let raw_config = metadata_sys::get(bucket)
-                .await
-                .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
-                .encryption_config_xml
-                .clone();
-            let config_xml = checked_raw_xml(&config, raw_config, deserialize::<ServerSideEncryptionConfiguration>)?;
-
-            Ok(Some(config_xml))
-        }
-        BUCKET_VERSIONING_CONFIG => {
-            let config = match metadata_sys::get_versioning_config(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
-                }
-            };
-            let raw_config = metadata_sys::get(bucket)
-                .await
-                .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
-                .versioning_config_xml
-                .clone();
-            let config_xml = checked_versioning_xml(&config, raw_config)?;
-
-            Ok(Some(config_xml))
-        }
-        BUCKET_REPLICATION_CONFIG => {
-            let config = match metadata_sys::get_replication_config(bucket).await {
-                Ok((res, _)) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
-                }
-            };
-            let raw_config = metadata_sys::get(bucket)
-                .await
-                .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
-                .replication_config_xml
-                .clone();
-            let config_xml = checked_raw_xml(&config, raw_config, deserialize::<ReplicationConfiguration>)?;
-
-            Ok(Some(config_xml))
-        }
-        BUCKET_TARGETS_FILE => {
-            let config: BucketTargets = match metadata_sys::get_bucket_targets_config(bucket).await {
-                Ok(res) => res,
-                Err(e) => {
-                    if e == StorageError::ConfigNotFound {
-                        return Ok(None);
-                    }
-                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
-                }
-            };
-
-            let config_json = serde_json::to_vec(&config.redacted_credentials())
-                .map_err(|e| s3_error!(InternalError, "serialize config failed: {e}"))?;
-
-            Ok(Some(config_json))
-        }
-        _ => Ok(None),
-    }
-}
-
 #[derive(Debug, Default, serde::Deserialize)]
 pub struct ExportBucketMetadataQuery {
-    #[serde(default)]
     pub bucket: String,
-    #[serde(default)]
-    pub diagnostic: bool,
 }
 
 pub struct ExportBucketMetadata {}
@@ -361,7 +169,6 @@ impl Operation for ExportBucketMetadata {
         };
 
         let mut zip_writer = ZipWriter::new(Cursor::new(Vec::new()));
-        let mut errors = Vec::new();
 
         let confs = [
             BUCKET_POLICY_CONFIG,
@@ -379,47 +186,242 @@ impl Operation for ExportBucketMetadata {
         for bucket in buckets {
             for &conf in confs.iter() {
                 let conf_path = path_join_buf(&[bucket.name.as_str(), conf]);
-                let config = match exported_bucket_config(&bucket.name, conf).await {
-                    Ok(Some(config)) => config,
-                    Ok(None) => continue,
-                    Err(error) if !query.diagnostic => return Err(error),
-                    Err(_) => {
-                        errors.push(serde_json::json!({
-                            "bucket": bucket.name,
-                            "config": conf,
-                            "code": "configuration_unavailable",
-                        }));
-                        continue;
+                match conf {
+                    BUCKET_POLICY_CONFIG => {
+                        let config: BucketPolicy = match metadata_sys::get_bucket_policy(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "failed to load bucket metadata: {e}"));
+                            }
+                        };
+                        let config_json = serde_json::to_vec(&config)
+                            .map_err(|e| s3_error!(InternalError, "failed to serialize config: {e}"))?;
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "failed to start archive entry: {e}"))?;
+                        zip_writer
+                            .write_all(&config_json)
+                            .map_err(|e| s3_error!(InternalError, "failed to write archive entry: {e}"))?;
                     }
-                };
-                let conf_path = if query.diagnostic {
-                    path_join_buf(&[DIAGNOSTIC_EXPORT_PREFIX, &conf_path])
-                } else {
-                    conf_path
-                };
-                zip_writer
-                    .start_file(conf_path, SimpleFileOptions::default())
-                    .map_err(|e| s3_error!(InternalError, "failed to start archive entry: {e}"))?;
-                zip_writer
-                    .write_all(&config)
-                    .map_err(|e| s3_error!(InternalError, "failed to write archive entry: {e}"))?;
-            }
-        }
+                    BUCKET_NOTIFICATION_CONFIG => {
+                        let config: s3s::dto::NotificationConfiguration =
+                            match metadata_sys::get_notification_config(&bucket.name).await {
+                                Ok(Some(res)) => res,
+                                Err(e) => {
+                                    if e == StorageError::ConfigNotFound {
+                                        continue;
+                                    }
+                                    return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
+                                }
+                                Ok(None) => continue,
+                            };
 
-        if query.diagnostic {
-            let manifest = serde_json::to_vec(&serde_json::json!({
-                "version": 1,
-                "mode": "diagnostic",
-                "complete": errors.is_empty(),
-                "errors": errors,
-            }))
-            .map_err(|e| s3_error!(InternalError, "failed to serialize diagnostic manifest: {e}"))?;
-            zip_writer
-                .start_file(DIAGNOSTIC_EXPORT_MANIFEST, SimpleFileOptions::default())
-                .map_err(|e| s3_error!(InternalError, "failed to start diagnostic manifest: {e}"))?;
-            zip_writer
-                .write_all(&manifest)
-                .map_err(|e| s3_error!(InternalError, "failed to write diagnostic manifest: {e}"))?;
+                        let raw_config = metadata_sys::get(&bucket.name)
+                            .await
+                            .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
+                            .notification_config_xml
+                            .clone();
+                        let config_xml =
+                            checked_raw_xml(&config, raw_config, deserialize::<s3s::dto::NotificationConfiguration>)?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "start file failed: {e}"))?;
+                        zip_writer
+                            .write_all(&config_xml)
+                            .map_err(|e| s3_error!(InternalError, "write file failed: {e}"))?;
+                    }
+                    BUCKET_LIFECYCLE_CONFIG => {
+                        let config: BucketLifecycleConfiguration = match metadata_sys::get_lifecycle_config(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "failed to load bucket metadata: {e}"));
+                            }
+                        };
+                        let raw_config = metadata_sys::get(&bucket.name)
+                            .await
+                            .map_err(|e| export_internal_error(format!("failed to load bucket metadata: {e}")))?
+                            .lifecycle_config_xml
+                            .clone();
+                        let config_xml = checked_raw_xml(&config, raw_config, deserialize::<BucketLifecycleConfiguration>)?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "failed to start archive entry: {e}"))?;
+                        zip_writer
+                            .write_all(&config_xml)
+                            .map_err(|e| s3_error!(InternalError, "failed to write archive entry: {e}"))?;
+                    }
+                    BUCKET_TAGGING_CONFIG => {
+                        let config: Tagging = match metadata_sys::get_tagging_config(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "failed to load bucket metadata: {e}"));
+                            }
+                        };
+                        let raw_config = metadata_sys::get(&bucket.name)
+                            .await
+                            .map_err(|e| export_internal_error(format!("failed to load bucket metadata: {e}")))?
+                            .tagging_config_xml
+                            .clone();
+                        let config_xml = checked_raw_xml(&config, raw_config, deserialize::<Tagging>)?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "failed to start archive entry: {e}"))?;
+                        zip_writer
+                            .write_all(&config_xml)
+                            .map_err(|e| s3_error!(InternalError, "failed to write archive entry: {e}"))?;
+                    }
+                    BUCKET_QUOTA_CONFIG_FILE => {
+                        let config: BucketQuota = match metadata_sys::get_quota_config(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
+                            }
+                        };
+                        let config_json =
+                            serde_json::to_vec(&config).map_err(|e| s3_error!(InternalError, "serialize config failed: {e}"))?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "start file failed: {e}"))?;
+                        zip_writer
+                            .write_all(&config_json)
+                            .map_err(|e| s3_error!(InternalError, "write file failed: {e}"))?;
+                    }
+                    OBJECT_LOCK_CONFIG => {
+                        let config = match metadata_sys::get_object_lock_config(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
+                            }
+                        };
+                        let raw_config = metadata_sys::get(&bucket.name)
+                            .await
+                            .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
+                            .object_lock_config_xml
+                            .clone();
+                        let config_xml = checked_raw_xml(&config, raw_config, deserialize::<ObjectLockConfiguration>)?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "start file failed: {e}"))?;
+                        zip_writer
+                            .write_all(&config_xml)
+                            .map_err(|e| s3_error!(InternalError, "write file failed: {e}"))?;
+                    }
+                    BUCKET_SSECONFIG => {
+                        let config = match metadata_sys::get_sse_config(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
+                            }
+                        };
+                        let raw_config = metadata_sys::get(&bucket.name)
+                            .await
+                            .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
+                            .encryption_config_xml
+                            .clone();
+                        let config_xml = checked_raw_xml(&config, raw_config, deserialize::<ServerSideEncryptionConfiguration>)?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "start file failed: {e}"))?;
+                        zip_writer
+                            .write_all(&config_xml)
+                            .map_err(|e| s3_error!(InternalError, "write file failed: {e}"))?;
+                    }
+                    BUCKET_VERSIONING_CONFIG => {
+                        let config = match metadata_sys::get_versioning_config(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
+                            }
+                        };
+                        let raw_config = metadata_sys::get(&bucket.name)
+                            .await
+                            .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
+                            .versioning_config_xml
+                            .clone();
+                        let config_xml = checked_versioning_xml(&config, raw_config)?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "start file failed: {e}"))?;
+                        zip_writer
+                            .write_all(&config_xml)
+                            .map_err(|e| s3_error!(InternalError, "write file failed: {e}"))?;
+                    }
+                    BUCKET_REPLICATION_CONFIG => {
+                        let config = match metadata_sys::get_replication_config(&bucket.name).await {
+                            Ok((res, _)) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
+                            }
+                        };
+                        let raw_config = metadata_sys::get(&bucket.name)
+                            .await
+                            .map_err(|e| export_internal_error(format!("get bucket metadata failed: {e}")))?
+                            .replication_config_xml
+                            .clone();
+                        let config_xml = checked_raw_xml(&config, raw_config, deserialize::<ReplicationConfiguration>)?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "start file failed: {e}"))?;
+                        zip_writer
+                            .write_all(&config_xml)
+                            .map_err(|e| s3_error!(InternalError, "write file failed: {e}"))?;
+                    }
+                    BUCKET_TARGETS_FILE => {
+                        let config: BucketTargets = match metadata_sys::get_bucket_targets_config(&bucket.name).await {
+                            Ok(res) => res,
+                            Err(e) => {
+                                if e == StorageError::ConfigNotFound {
+                                    continue;
+                                }
+                                return Err(s3_error!(InternalError, "get bucket metadata failed: {e}"));
+                            }
+                        };
+
+                        let config_json = serde_json::to_vec(&config.redacted_credentials())
+                            .map_err(|e| s3_error!(InternalError, "serialize config failed: {e}"))?;
+
+                        zip_writer
+                            .start_file(conf_path, SimpleFileOptions::default())
+                            .map_err(|e| s3_error!(InternalError, "start file failed: {e}"))?;
+                        zip_writer
+                            .write_all(&config_json)
+                            .map_err(|e| s3_error!(InternalError, "write file failed: {e}"))?;
+                    }
+                    _ => {}
+                }
+            }
         }
 
         let zip_bytes = zip_writer
@@ -429,17 +431,8 @@ impl Operation for ExportBucketMetadata {
         header.insert(CONTENT_TYPE, "application/zip".parse().expect("valid header value"));
         header.insert(
             CONTENT_DISPOSITION,
-            if query.diagnostic {
-                "attachment; filename=bucket-meta-diagnostic.zip"
-            } else {
-                "attachment; filename=bucket-meta.zip"
-            }
-            .parse()
-            .expect("valid header value"),
+            "attachment; filename=bucket-meta.zip".parse().expect("valid header value"),
         );
-        if query.diagnostic {
-            header.insert("x-rustfs-bucket-metadata-export", "diagnostic".parse().expect("valid header value"));
-        }
         header.insert(CONTENT_LENGTH, zip_bytes.get_ref().len().to_string().parse().expect("valid header value"));
         Ok(S3Response::with_headers((StatusCode::OK, Body::from(zip_bytes.into_inner())), header))
     }
@@ -506,18 +499,6 @@ impl Operation for ImportBucketMetadata {
             file_contents.push((file_path, content));
         }
 
-        // Reject the whole archive before creating buckets or writing configs,
-        // even when the marker is malformed or follows ordinary config entries.
-        if file_contents.iter().any(|(path, _)| {
-            path == DIAGNOSTIC_EXPORT_MANIFEST
-                || path == DIAGNOSTIC_EXPORT_PREFIX
-                || path
-                    .strip_prefix(DIAGNOSTIC_EXPORT_PREFIX)
-                    .is_some_and(|suffix| suffix.starts_with('/'))
-        }) {
-            return Err(s3_error!(InvalidRequest, "diagnostic bucket metadata archives cannot be imported"));
-        }
-
         let durable_quota_import = imported_quota_requires_fleet_proof(&file_contents)?;
         let quota_fleet_proof =
             if durable_quota_import {
@@ -1438,246 +1419,6 @@ mod backup_zip_compatibility_tests {
         assert_eq!(response.output.0, StatusCode::OK);
     }
 
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn diagnostic_export_isolated_errors_and_import_recovers_unreadable_targets() {
-        const HEALTHY: &str = "diagnostic-healthy";
-        const UNREADABLE: &str = "diagnostic-unreadable";
-        const REPLACEMENT_TARGETS: &[u8] = br#"{"targets":[]}"#;
-        const SECRET: &str = "diagnostic-must-not-expose-this-secret";
-
-        let _ = rustfs_credentials::init_global_action_credentials(
-            Some(ROOT_ACCESS_KEY.to_string()),
-            Some(ROOT_SECRET_KEY.to_string()),
-        );
-        let temp = tempfile::tempdir().expect("create diagnostic export test root");
-        let env = rustfs_test_utils::TestECStoreEnv::builder()
-            .base_dir(temp.path())
-            .disk_count(1)
-            .build()
-            .await;
-        env.make_bucket(HEALTHY, false).await;
-        env.make_bucket(UNREADABLE, false).await;
-        rustfs_iam::store::object::ObjectStore::new(Arc::clone(&env.ecstore))
-            .save_iam_config(serde_json::json!({"version": 1}), format!("{}/format.json", *IAM_CONFIG_PREFIX))
-            .await
-            .expect("seed IAM format");
-        let iam = rustfs_iam::build_iam_sys(Arc::clone(&env.ecstore))
-            .await
-            .expect("build test IAM");
-        publish_test_app_context(Arc::new(AppContext::with_default_interfaces(
-            Arc::clone(&env.ecstore),
-            iam,
-            Arc::new(rustfs_kms::KmsServiceManager::new()),
-        )));
-        metadata_sys::update(HEALTHY, BUCKET_VERSIONING_CONFIG, VERSIONING_XML.to_vec())
-            .await
-            .expect("seed healthy bucket config");
-
-        let minio_blob = hex_simd::decode_to_vec(
-            include_str!("../../../../crates/ecstore/tests/fixtures/minio/bucket_metadata.blob.hex").trim(),
-        )
-        .expect("decode real MinIO metadata fixture");
-        let minio_metadata = BucketMetadata::unmarshal(&minio_blob[4..]).expect("read MinIO metadata fixture");
-        let targets_array = format!(r#"[{{"credentials":{{"secretKey":"{SECRET}"}}}}]"#).into_bytes();
-        for unreadable_targets in [targets_array, minio_metadata.bucket_targets_config_json] {
-            let mut metadata = metadata_sys::get_config_from_disk(UNREADABLE)
-                .await
-                .expect("load bucket before simulating MinIO targets");
-            let incarnation = metadata.bucket_incarnation_id;
-            metadata.bucket_targets_config_json = unreadable_targets.clone();
-            metadata
-                .save_with_store(Arc::clone(&env.ecstore))
-                .await
-                .expect("persist unreadable targets fixture");
-            crate::storage::storage_api::set_bucket_metadata(UNREADABLE.to_string(), metadata)
-                .await
-                .expect("publish unreadable targets fixture");
-            assert!(metadata_sys::get_bucket_targets_config(UNREADABLE).await.is_err());
-
-            let strict_error = ExportBucketMetadata {}
-                .call(
-                    admin_request(Method::GET, Uri::from_static("/rustfs/admin/v3/export-bucket-metadata"), Vec::new()),
-                    Params::new(),
-                )
-                .await
-                .expect_err("a complete export must fail closed on unreadable targets");
-            assert_eq!(*strict_error.code(), s3s::S3ErrorCode::InternalError);
-
-            let response = ExportBucketMetadata {}
-                .call(
-                    admin_request(
-                        Method::GET,
-                        Uri::from_static("/rustfs/admin/v3/export-bucket-metadata?diagnostic=true"),
-                        Vec::new(),
-                    ),
-                    Params::new(),
-                )
-                .await
-                .expect("one unreadable bucket must not abort diagnostic export");
-            assert_eq!(response.output.0, StatusCode::OK);
-            assert_eq!(response.headers["x-rustfs-bucket-metadata-export"], "diagnostic");
-            assert_eq!(response.headers[CONTENT_DISPOSITION], "attachment; filename=bucket-meta-diagnostic.zip");
-            let bytes = response.output.1.collect().await.expect("read diagnostic archive").to_bytes();
-            let mut archive = ZipArchive::new(Cursor::new(&bytes)).expect("open diagnostic archive");
-            let mut files = HashMap::new();
-            for index in 0..archive.len() {
-                let mut file = archive.by_index(index).expect("read diagnostic entry");
-                let mut content = Vec::new();
-                file.read_to_end(&mut content).expect("read diagnostic config");
-                assert!(!content.windows(SECRET.len()).any(|window| window == SECRET.as_bytes()));
-                assert!(file.name() == DIAGNOSTIC_EXPORT_MANIFEST || file.name().starts_with("_diagnostic/"));
-                files.insert(file.name().to_string(), content);
-            }
-            assert_eq!(files[&format!("_diagnostic/{HEALTHY}/{BUCKET_VERSIONING_CONFIG}")], VERSIONING_XML);
-            assert!(files.contains_key(&format!("_diagnostic/{UNREADABLE}/{BUCKET_VERSIONING_CONFIG}")));
-            assert!(!files.contains_key(&format!("_diagnostic/{UNREADABLE}/{BUCKET_TARGETS_FILE}")));
-            let manifest: serde_json::Value =
-                serde_json::from_slice(&files[DIAGNOSTIC_EXPORT_MANIFEST]).expect("decode diagnostic manifest");
-            assert_eq!(
-                manifest,
-                serde_json::json!({
-                    "version": 1,
-                    "mode": "diagnostic",
-                    "complete": false,
-                    "errors": [{ "bucket": UNREADABLE, "config": BUCKET_TARGETS_FILE, "code": "configuration_unavailable" }],
-                })
-            );
-
-            let error = ImportBucketMetadata {}
-                .call(
-                    admin_request(Method::PUT, Uri::from_static("/rustfs/admin/v3/import-bucket-metadata"), bytes.to_vec()),
-                    Params::new(),
-                )
-                .await
-                .expect_err("diagnostic exports are never backups");
-            assert_eq!(*error.code(), s3s::S3ErrorCode::InvalidRequest);
-            assert_eq!(
-                metadata_sys::get_config_from_disk(UNREADABLE)
-                    .await
-                    .expect("load rejected import state")
-                    .bucket_targets_config_json,
-                unreadable_targets
-            );
-
-            import_archive(zip_with_entries(UNREADABLE, &[(BUCKET_TARGETS_FILE, REPLACEMENT_TARGETS)])).await;
-            let recovered = metadata_sys::get_config_from_disk(UNREADABLE)
-                .await
-                .expect("read recovered targets from disk");
-            assert_eq!(recovered.bucket_incarnation_id, incarnation);
-            assert_eq!(recovered.bucket_targets_config_json, REPLACEMENT_TARGETS);
-            assert!(
-                metadata_sys::get_bucket_targets_config(UNREADABLE)
-                    .await
-                    .expect("existing import API must recover targets readers")
-                    .is_empty()
-            );
-        }
-
-        // The marker may be malformed, come last, or be removed while the
-        // reserved directory remains. None may allow an earlier config write.
-        for marker in [
-            DIAGNOSTIC_EXPORT_MANIFEST.to_string(),
-            DIAGNOSTIC_EXPORT_PREFIX.to_string(),
-            format!("{DIAGNOSTIC_EXPORT_PREFIX}/bucket/config"),
-        ] {
-            let mut writer = ZipWriter::new(Cursor::new(Vec::new()));
-            writer
-                .start_file(format!("{HEALTHY}/{BUCKET_VERSIONING_CONFIG}"), SimpleFileOptions::default())
-                .expect("start ordinary config before diagnostic marker");
-            writer
-                .write_all(b"<VersioningConfiguration><Status>Suspended</Status></VersioningConfiguration>")
-                .expect("write ordinary config before diagnostic marker");
-            writer
-                .start_file(
-                    format!("diagnostic-never-created/{BUCKET_VERSIONING_CONFIG}"),
-                    SimpleFileOptions::default(),
-                )
-                .expect("start a nonexistent bucket config before diagnostic marker");
-            writer.write_all(VERSIONING_XML).expect("write nonexistent bucket config");
-            writer
-                .start_file(marker, SimpleFileOptions::default())
-                .expect("start diagnostic marker");
-            writer.write_all(b"not json").expect("write malformed diagnostic marker");
-            let error = ImportBucketMetadata {}
-                .call(
-                    admin_request(
-                        Method::PUT,
-                        Uri::from_static("/rustfs/admin/v3/import-bucket-metadata"),
-                        writer.finish().expect("finish marked archive").into_inner(),
-                    ),
-                    Params::new(),
-                )
-                .await
-                .expect_err("diagnostic preflight must reject before any config write");
-            assert_eq!(*error.code(), s3s::S3ErrorCode::InvalidRequest);
-            assert_eq!(
-                metadata_sys::get_config_from_disk(HEALTHY)
-                    .await
-                    .expect("read healthy config after rejected import")
-                    .versioning_config_xml,
-                VERSIONING_XML
-            );
-            assert!(
-                env.ecstore
-                    .get_bucket_info("diagnostic-never-created", &BucketOptions::default())
-                    .await
-                    .is_err(),
-                "diagnostic preflight must reject before bucket creation"
-            );
-        }
-
-        let response = ExportBucketMetadata {}
-            .call(
-                admin_request(
-                    Method::GET,
-                    Uri::from_static("/rustfs/admin/v3/export-bucket-metadata?diagnostic=true"),
-                    Vec::new(),
-                ),
-                Params::new(),
-            )
-            .await
-            .expect("diagnostic export after recovery");
-        let bytes = response
-            .output
-            .1
-            .collect()
-            .await
-            .expect("read complete diagnostic archive")
-            .to_bytes();
-        let mut archive = ZipArchive::new(Cursor::new(&bytes)).expect("open complete diagnostic archive");
-        let manifest: serde_json::Value = serde_json::from_reader(
-            archive
-                .by_name(DIAGNOSTIC_EXPORT_MANIFEST)
-                .expect("complete diagnostic manifest"),
-        )
-        .expect("parse complete diagnostic manifest");
-        assert_eq!(manifest["complete"], true);
-        let error = ImportBucketMetadata {}
-            .call(
-                admin_request(Method::PUT, Uri::from_static("/rustfs/admin/v3/import-bucket-metadata"), bytes.to_vec()),
-                Params::new(),
-            )
-            .await
-            .expect_err("complete diagnostics must still reject import");
-        assert_eq!(*error.code(), s3s::S3ErrorCode::InvalidRequest);
-
-        let response = ExportBucketMetadata {}
-            .call(
-                admin_request(Method::GET, Uri::from_static("/rustfs/admin/v3/export-bucket-metadata"), Vec::new()),
-                Params::new(),
-            )
-            .await
-            .expect("ordinary cluster export must work after API recovery");
-        assert!(!response.headers.contains_key("x-rustfs-bucket-metadata-export"));
-        assert_eq!(response.headers[CONTENT_DISPOSITION], "attachment; filename=bucket-meta.zip");
-        let bytes = response.output.1.collect().await.expect("read ordinary archive").to_bytes();
-        let mut archive = ZipArchive::new(Cursor::new(bytes)).expect("open ordinary archive");
-        assert!(archive.by_name(DIAGNOSTIC_EXPORT_MANIFEST).is_err());
-        assert!(archive.by_name(&format!("{HEALTHY}/{BUCKET_VERSIONING_CONFIG}")).is_ok());
-        assert!(archive.by_name(&format!("{UNREADABLE}/{BUCKET_TARGETS_FILE}")).is_ok());
-    }
-
     #[tokio::test]
     #[serial_test::serial]
     async fn g_zip_001_002_003_use_real_admin_archive_and_persistence_paths() {

rustfs/src/admin/handlers/on_demand_migration.rs

@@ -38,6 +38,16 @@ use crate::admin::runtime_sources::{
 };
 use crate::admin::storage_api::bucket::metadata::BUCKET_ON_DEMAND_MIGRATION_CONFIG;
 use crate::admin::storage_api::bucket::metadata_sys;
+use crate::admin::storage_api::bucket::on_demand_migration::backfill::{
+    BackfillCheckpoint, BackfillError, BackfillRequest, BackfillState, SkipExisting, global_backfill_runner,
+};
+use crate::admin::storage_api::bucket::on_demand_migration::source_client::{
+    SourceClient, SourceClientSpec, SourceError, SourceProbe, SourceProvider, SourceTimeouts,
+};
+use crate::admin::storage_api::bucket::on_demand_migration::{
+    OdmBucketSnapshot, OnDemandMigrationConfig, OnDemandMigrationConfigError, OnDemandMigrationSys, PathStyle, ValidationContext,
+    source_backend_spec,
+};
 use crate::admin::storage_api::bucket::remote_s3_client::{
     PathStyle as RemotePathStyle, RemoteCredentials, RemoteS3ClientError, RemoteS3RetryPolicy,
 };
@@ -48,16 +58,6 @@ use crate::admin::utils::{extract_query_params, read_compatible_admin_body};
 use crate::error::ApiError;
 use crate::license::license_check;
 use crate::module_switches::{ENV_ON_DEMAND_MIGRATION_ENABLED, on_demand_migration_enabled_from_env};
-use crate::on_demand_migration::backfill::{
-    BackfillCheckpoint, BackfillError, BackfillRequest, BackfillState, SkipExisting, global_backfill_runner,
-};
-use crate::on_demand_migration::source_client::{
-    SourceClient, SourceClientSpec, SourceError, SourceProbe, SourceProvider, SourceTimeouts,
-};
-use crate::on_demand_migration::{
-    OdmBucketSnapshot, OnDemandMigrationConfig, OnDemandMigrationConfigError, OnDemandMigrationSys, PathStyle, ValidationContext,
-    source_backend_spec,
-};
 use crate::server::ADMIN_PREFIX;
 use hyper::{Method, StatusCode};
 use matchit::Params;
@@ -90,8 +90,6 @@ const BACKFILL_OP_CANCEL: &str = "cancel";
 pub(crate) const ERR_CODE_MODULE_DISABLED: &str = "OnDemandMigrationDisabled";
 /// Error code returned when the source bucket did not answer the probe.
 pub(crate) const ERR_CODE_SOURCE_UNREACHABLE: &str = "OnDemandMigrationSourceUnreachable";
-/// Error code returned when the configured provider was excluded at build time.
-pub(crate) const ERR_CODE_BACKEND_NOT_COMPILED: &str = "OnDemandMigrationBackendNotCompiled";
 /// Error code returned by `GET` when the bucket has no configuration.
 pub(crate) const ERR_CODE_NO_SUCH_CONFIGURATION: &str = "NoSuchConfiguration";
 /// Error code (409) returned by `start` while a backfill job holds the lease.
@@ -580,7 +578,7 @@ async fn validate_config(bucket: &str, config: &OnDemandMigrationConfig) -> S3Re
 }
 
 fn source_provider(config: &OnDemandMigrationConfig) -> SourceProvider {
-    use crate::on_demand_migration::Provider;
+    use crate::admin::storage_api::bucket::on_demand_migration::Provider;
     match config.source.provider {
         Provider::S3 => SourceProvider::S3,
         Provider::Aws => SourceProvider::Aws,
@@ -632,17 +630,12 @@ pub(crate) fn source_client_spec(config: &OnDemandMigrationConfig) -> SourceClie
     }
 }
 
-/// Distinguishes excluded backends from invalid endpoint, CA or credentials.
-/// Anonymous S3 sources are not wired yet
+/// Builder failures are input errors: the endpoint policy, the CA PEM or the
+/// credentials the operator supplied. Anonymous sources are not wired yet
 /// (ODM-05 adds the credential-less path), so `MissingCredentials` is a 400
 /// naming the field instead of an opaque internal error.
 fn client_build_error(err: RemoteS3ClientError) -> S3Error {
     match err {
-        RemoteS3ClientError::BackendNotCompiled(provider) => custom_error(
-            ERR_CODE_BACKEND_NOT_COMPILED,
-            StatusCode::NOT_IMPLEMENTED,
-            format!("the {provider} backend is not included in this build; rebuild with the gcs feature"),
-        ),
         RemoteS3ClientError::MissingCredentials => admin_s3_error(
             S3ErrorCode::InvalidArgument,
             "source.credentials is required: anonymous sources are not supported yet",
@@ -787,7 +780,7 @@ impl Operation for GetBucketOnDemandMigrationHandler {
         let bucket = bucket_from_params(&params)?;
         let cred = authorize_for_bucket(&req, AdminAction::GetBucketOnDemandMigrationAction, &bucket).await?;
 
-        let Some((config, updated_at)) = crate::on_demand_migration::config::get_config(&bucket).await.map_err(|err| {
+        let Some((config, updated_at)) = metadata_sys::get_on_demand_migration_config(&bucket).await.map_err(|err| {
             admin_s3_error(S3ErrorCode::InternalError, format!("failed to read on-demand migration config: {err}"))
         })?
         else {
@@ -846,7 +839,7 @@ impl Operation for GetBucketOnDemandMigrationStatusHandler {
         let bucket = bucket_from_params(&params)?;
         let cred = authorize_for_bucket(&req, AdminAction::GetBucketOnDemandMigrationAction, &bucket).await?;
 
-        let config = crate::on_demand_migration::config::get_config(&bucket).await.map_err(|err| {
+        let config = metadata_sys::get_on_demand_migration_config(&bucket).await.map_err(|err| {
             admin_s3_error(S3ErrorCode::InternalError, format!("failed to read on-demand migration config: {err}"))
         })?;
         let runtime = OnDemandMigrationSys::get().bucket_snapshot(&bucket);
@@ -1295,14 +1288,6 @@ mod tests {
         assert!(err.message().unwrap_or_default().contains("source.credentials"));
     }
 
-    #[test]
-    fn backend_not_compiled_is_distinct_from_invalid_credentials() {
-        let err = client_build_error(RemoteS3ClientError::BackendNotCompiled("gcs_native"));
-        assert_eq!(err.code(), &S3ErrorCode::Custom(ERR_CODE_BACKEND_NOT_COMPILED.into()));
-        assert_eq!(err.status_code(), Some(StatusCode::NOT_IMPLEMENTED));
-        assert!(err.message().unwrap_or_default().contains("gcs feature"));
-    }
-
     #[test]
     fn module_switch_defaults_on_and_reads_the_env() {
         temp_env::with_var(ENV_ON_DEMAND_MIGRATION_ENABLED, None::<&str>, || assert!(module_enabled()));
@@ -1763,19 +1748,6 @@ mod store_tests {
                 assert_eq!(body["inflight_pulls"], Value::from(0));
                 assert_eq!(body["queue_depth"], Value::from(0));
 
-                // A malformed replacement cannot overwrite the saved source.
-                let before = metadata_sys::get(BUCKET).await.expect("saved metadata");
-                for invalid in [b"not-json".to_vec(), br#"{"source":{"provider":"s3"},"bogus":1}"#.to_vec()] {
-                    let err = SetBucketOnDemandMigrationHandler {}
-                        .call(root_request(Method::PUT, config_uri(""), invalid), bucket_params(&router))
-                        .await
-                        .expect_err("malformed replacement must be rejected");
-                    assert_eq!(err.code(), &S3ErrorCode::InvalidArgument);
-                    let after = metadata_sys::get(BUCKET).await.expect("saved metadata remains readable");
-                    assert_eq!(after.on_demand_migration_config_json, before.on_demand_migration_config_json);
-                    assert_eq!(after.on_demand_migration_config_updated_at, before.on_demand_migration_config_updated_at);
-                }
-
                 // The peer fan-out ran: the single unreachable peer is reported.
                 let context = crate::admin::runtime_sources::current_app_context();
                 let err = reload_peers(context.as_deref(), BUCKET)

rustfs/src/admin/storage_api.rs

@@ -20,8 +20,8 @@ use time::OffsetDateTime;
 
 mod ecstore_bucket {
     pub(crate) use crate::storage::storage_api::ecstore_bucket::{
-        bandwidth, bucket_target_sys, durability, lifecycle, metadata, metadata_sys, object_lock, quota, remote_s3_client,
-        replication, target, utils, versioning, versioning_sys,
+        bandwidth, bucket_target_sys, durability, lifecycle, metadata, metadata_sys, object_lock, on_demand_migration, quota,
+        remote_s3_client, replication, target, utils, versioning, versioning_sys,
     };
 }
 
@@ -284,6 +284,35 @@ pub(crate) mod durability {
     pub(crate) type BucketDurabilityConfig = super::ecstore_bucket::durability::BucketDurabilityConfig;
 }
 
+pub(crate) mod on_demand_migration {
+    pub(crate) type OdmBucketSnapshot = super::ecstore_bucket::on_demand_migration::OdmBucketSnapshot;
+    pub(crate) type OnDemandMigrationConfig = super::ecstore_bucket::on_demand_migration::OnDemandMigrationConfig;
+    pub(crate) type OnDemandMigrationConfigError = super::ecstore_bucket::on_demand_migration::OnDemandMigrationConfigError;
+    pub(crate) type OnDemandMigrationSys = super::ecstore_bucket::on_demand_migration::OnDemandMigrationSys;
+    pub(crate) type PathStyle = super::ecstore_bucket::on_demand_migration::PathStyle;
+    pub(crate) type Provider = super::ecstore_bucket::on_demand_migration::Provider;
+    pub(crate) type ValidationContext<'a> = super::ecstore_bucket::on_demand_migration::ValidationContext<'a>;
+    pub(crate) use super::ecstore_bucket::on_demand_migration::source_backend_spec;
+
+    pub(crate) mod backfill {
+        pub(crate) type BackfillCheckpoint = super::super::ecstore_bucket::on_demand_migration::backfill::BackfillCheckpoint;
+        pub(crate) type BackfillError = super::super::ecstore_bucket::on_demand_migration::backfill::BackfillError;
+        pub(crate) type BackfillRequest = super::super::ecstore_bucket::on_demand_migration::backfill::BackfillRequest;
+        pub(crate) type BackfillState = super::super::ecstore_bucket::on_demand_migration::backfill::BackfillState;
+        pub(crate) type SkipExisting = super::super::ecstore_bucket::on_demand_migration::backfill::SkipExisting;
+        pub(crate) use super::super::ecstore_bucket::on_demand_migration::backfill::global_backfill_runner;
+    }
+
+    pub(crate) mod source_client {
+        pub(crate) type SourceClient = super::super::ecstore_bucket::on_demand_migration::source_client::SourceClient;
+        pub(crate) type SourceClientSpec = super::super::ecstore_bucket::on_demand_migration::source_client::SourceClientSpec;
+        pub(crate) type SourceError = super::super::ecstore_bucket::on_demand_migration::source_client::SourceError;
+        pub(crate) type SourceProbe = super::super::ecstore_bucket::on_demand_migration::source_client::SourceProbe;
+        pub(crate) type SourceProvider = super::super::ecstore_bucket::on_demand_migration::source_client::SourceProvider;
+        pub(crate) type SourceTimeouts = super::super::ecstore_bucket::on_demand_migration::source_client::SourceTimeouts;
+    }
+}
+
 pub(crate) mod remote_s3_client {
     pub(crate) type PathStyle = super::ecstore_bucket::remote_s3_client::PathStyle;
     pub(crate) type RemoteCredentials = super::ecstore_bucket::remote_s3_client::RemoteCredentials;
@@ -426,6 +455,12 @@ pub(crate) mod metadata_sys {
         super::ecstore_bucket::metadata_sys::get_durability_config(bucket).await
     }
 
+    pub(crate) async fn get_on_demand_migration_config(
+        bucket: &str,
+    ) -> Result<Option<(super::on_demand_migration::OnDemandMigrationConfig, OffsetDateTime)>> {
+        super::ecstore_bucket::metadata_sys::get_on_demand_migration_config(bucket).await
+    }
+
     pub(crate) async fn get_quota_config(bucket: &str) -> Result<(BucketQuota, OffsetDateTime)> {
         super::ecstore_bucket::metadata_sys::get_quota_config(bucket).await
     }
@@ -878,6 +913,7 @@ pub(crate) mod bucket {
     pub(crate) use super::lifecycle;
     pub(crate) use super::metadata;
     pub(crate) use super::metadata_sys;
+    pub(crate) use super::on_demand_migration;
     pub(crate) use super::quota;
     pub(crate) use super::remote_s3_client;
     pub(crate) use super::replication;

rustfs/src/app/bucket_list_through.rs

@@ -25,19 +25,20 @@
 use super::storage_api::bucket_usecase::ECStore;
 use super::storage_api::bucket_usecase::StorageObjectInfo as ObjectInfo;
 use super::storage_api::bucket_usecase::StorageObjectOptions;
-use super::storage_api::bucket_usecase::bucket::versioning_sys::BucketVersioningSys;
-use super::storage_api::bucket_usecase::contract::list::{ListObjectsV2Info as StorageListObjectsV2Info, ListOperations as _};
-use super::storage_api::bucket_usecase::contract::object::ObjectOperations as _;
-use super::storage_api::bucket_usecase::s3::{S3Error, S3ErrorCode, S3Request, S3Result};
-use super::storage_api::bucket_usecase::s3_api::bucket::ListObjectsV2Params;
-use crate::app::object::shared::{odm_source_unavailable_error, odm_state_error_class};
-use crate::error::ApiError;
-use crate::on_demand_migration::{
+use super::storage_api::bucket_usecase::bucket::on_demand_migration::{
     BucketOdmState, ListEntryKey, ListPageError, ListThroughCursor, ListThroughMerger, ListThroughToken, ListThroughTokenError,
     MergeSide, OnDemandMigrationSys, SOURCE_LIST_MAX_RATE_WAIT, SourceClient, SourceError, SourceErrorPolicy, SourceListPlan,
     SourceListRequest, SourceObject, SourcePage, decode_continuation_token, source_list_plan,
 };
+use super::storage_api::bucket_usecase::bucket::versioning_sys::BucketVersioningSys;
+use super::storage_api::bucket_usecase::contract::list::{ListObjectsV2Info as StorageListObjectsV2Info, ListOperations as _};
+use super::storage_api::bucket_usecase::contract::object::ObjectOperations as _;
+use super::storage_api::bucket_usecase::s3::{S3Error, S3ErrorCode, S3Result};
+use super::storage_api::bucket_usecase::s3_api::bucket::ListObjectsV2Params;
+use crate::app::object::shared::{odm_source_unavailable_error, odm_state_error_class};
+use crate::error::ApiError;
 use futures::StreamExt;
+use http::HeaderMap;
 use rustfs_utils::http::{SUFFIX_SOURCE_PROXY_REQUEST, get_header};
 use std::sync::Arc;
 use std::time::Instant;
@@ -100,38 +101,16 @@ fn invalid_continuation_token(err: &ListThroughTokenError) -> S3Error {
 /// bucket has no source, `list_through` is off, or the request carries the
 /// `source-proxy-request` anti-loop marker and therefore comes from a peer
 /// that must be answered locally.
-pub(crate) async fn list_through_state<T>(
-    store: &ECStore,
-    bucket: &str,
-    req: &S3Request<T>,
-    params: &ListObjectsV2Params,
-) -> S3Result<Option<Arc<BucketOdmState>>> {
-    if get_header(&req.headers, SUFFIX_SOURCE_PROXY_REQUEST).is_some() {
-        return Ok(None);
+pub(crate) fn list_through_state(bucket: &str, headers: &HeaderMap) -> Option<Arc<BucketOdmState>> {
+    if get_header(headers, SUFFIX_SOURCE_PROXY_REQUEST).is_some() {
+        return None;
     }
     let sys = OnDemandMigrationSys::get();
     if !sys.is_module_enabled() {
-        return Ok(None);
+        return None;
     }
-    let Some(state) = sys.state(bucket).filter(|state| state.config().policy.list_through) else {
-        return Ok(None);
-    };
-    if params.max_keys == 0
-        || matches!(
-            source_list_plan(&params.prefix, state.config().filter.prefix.as_deref(), params.delimiter.as_deref()),
-            SourceListPlan::Skip,
-        )
-    {
-        return Ok(None);
-    }
-    let Some(expected_incarnation) = super::storage_api::bucket_usecase::access::odm_read_generation(req, bucket)? else {
-        return Ok(None);
-    };
-    let incarnation = store.bucket_incarnation_id(bucket).await.map_err(ApiError::from)?;
-    if incarnation != expected_incarnation {
-        return Ok(None);
-    }
-    Ok(state.filter_incarnation(incarnation))
+    let state = sys.state(bucket)?;
+    state.config().policy.list_through.then_some(state)
 }
 
 /// A merged page plus whether the source had to be left out of it.
@@ -464,18 +443,14 @@ mod tests {
     use super::*;
     use crate::app::bucket_usecase::DefaultBucketUsecase;
     use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ecstore};
-    use crate::app::storage_api::bucket_usecase::s3::{
-        GetObjectInput, HeadObjectInput, ListObjectsInput, ListObjectsV2Input, ListObjectsV2Output, S3Request, S3Response,
-        XmlSerialize, XmlSerializer,
-    };
-    use crate::app::storage_api::test::StoragePutObjReader;
-    use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, DeleteBucketOptions, MakeBucketOptions};
-    use crate::app::storage_api::test::contract::object::ObjectIO as _;
-    use crate::on_demand_migration::{
+    use crate::app::storage_api::bucket_usecase::bucket::on_demand_migration::{
         FilterConfig, MAX_LIST_NO_PROGRESS_PAGES, OnDemandMigrationConfig, PathStyle, PolicyConfig, Provider, SourceConfig,
         SourceCredentials, TlsConfig,
     };
-    use http::HeaderMap;
+    use crate::app::storage_api::bucket_usecase::s3::{ListObjectsV2Input, ListObjectsV2Output, S3Request, S3Response};
+    use crate::app::storage_api::test::StoragePutObjReader;
+    use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, MakeBucketOptions};
+    use crate::app::storage_api::test::contract::object::ObjectIO as _;
     use std::time::Duration;
     use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
@@ -750,12 +725,7 @@ mod tests {
                 ..Default::default()
             },
         };
-        sys.apply_for_incarnation(
-            &bucket,
-            store.bucket_incarnation_id(&bucket).await.expect("bucket identity"),
-            Some(&config),
-        )
-        .await;
+        sys.apply(&bucket, Some(&config)).await;
         assert!(
             sys.state(&bucket).expect("ODM state installed").client().is_ok(),
             "fake source client must build"
@@ -825,219 +795,6 @@ mod tests {
         (result, requests)
     }
 
-    #[test]
-    #[serial_test::serial]
-    fn stale_bucket_state_cannot_send_get_head_or_list_to_the_source() {
-        run_large_stack_test("list-through-incarnation", || async {
-            temp_env::async_with_vars(
-                [
-                    ("RUSTFS_REPLICATION_ALLOW_LOOPBACK_TARGET", Some("true")),
-                    ("HTTP_PROXY", None),
-                    ("HTTPS_PROXY", None),
-                    ("ALL_PROXY", None),
-                    ("http_proxy", None),
-                    ("https_proxy", None),
-                    ("all_proxy", None),
-                    ("NO_PROXY", Some("*")),
-                    ("no_proxy", Some("*")),
-                ],
-                async {
-                    let (endpoint, server, stop) = list_source(std::iter::repeat(source_xml(None, false, Some("source")))).await;
-                    let (_guard, input) = source_policy_input(endpoint, SourceErrorPolicy::Propagate, None, None).await;
-                    let sys = OnDemandMigrationSys::get();
-                    let old = sys.state(&input.bucket).expect("original source state");
-                    let store = shared_gating_ecstore().await;
-                    let get = S3Request {
-                        input: GetObjectInput {
-                            bucket: input.bucket.clone(),
-                            key: "missing".into(),
-                            ..Default::default()
-                        },
-                        method: http::Method::GET,
-                        uri: http::Uri::from_static("/missing"),
-                        headers: HeaderMap::new(),
-                        extensions: http::Extensions::new(),
-                        credentials: None,
-                        region: None,
-                        service: None,
-                        trailing_headers: None,
-                    };
-                    let authorized_generation =
-                        super::super::storage_api::bucket_usecase::access::load_bucket_generation_from_store(
-                            &store,
-                            &get,
-                            &input.bucket,
-                        )
-                        .await
-                        .expect("capture the identity before authorization");
-                    store
-                        .delete_bucket(
-                            &input.bucket,
-                            &DeleteBucketOptions {
-                                force: true,
-                                ..Default::default()
-                            },
-                        )
-                        .await
-                        .expect("delete original bucket");
-                    store
-                        .make_bucket(&input.bucket, &MakeBucketOptions::default())
-                        .await
-                        .expect("recreate bucket");
-                    let replacement = store
-                        .bucket_incarnation_id(&input.bucket)
-                        .await
-                        .expect("replacement identity");
-                    assert_ne!(replacement, old.incarnation_id());
-                    sys.remove(&input.bucket);
-                    let mut without_source = get.clone();
-                    super::super::storage_api::bucket_usecase::access::prepare_odm_read_generation(
-                        &store,
-                        &mut without_source,
-                        &input.bucket,
-                    )
-                    .await;
-                    for state_incarnation in [old.incarnation_id(), replacement] {
-                        sys.apply_for_incarnation(&input.bucket, state_incarnation, Some(old.config()))
-                            .await;
-                        // Both a stale runtime and a newly published replacement must reject
-                        // requests already authorized for the deleted incarnation.
-                        for capture in 0..3 {
-                            if capture == 0 && state_incarnation == replacement {
-                                continue;
-                            }
-                            let mut get = if capture == 2 { without_source.clone() } else { get.clone() };
-                            if capture == 1 {
-                                get.extensions.insert(authorized_generation.clone());
-                            }
-                            let mut head = get.clone().map_input(|_| HeadObjectInput {
-                                bucket: input.bucket.clone(),
-                                key: "missing".into(),
-                                ..Default::default()
-                            });
-                            head.method = http::Method::HEAD;
-                            let mut list = get.clone().map_input(|_| input.clone());
-                            list.uri = http::Uri::from_static("/?list-type=2");
-                            let usecase = crate::app::object::DefaultObjectUsecase::from_global();
-                            let get_error = tokio::time::timeout(Duration::from_secs(10), usecase.execute_get_object(get))
-                                .await
-                                .expect("GET stays local")
-                                .expect_err("local object is absent");
-                            assert_eq!(*get_error.code(), S3ErrorCode::NoSuchKey);
-                            let head_error = tokio::time::timeout(Duration::from_secs(10), usecase.execute_head_object(head))
-                                .await
-                                .expect("HEAD stays local")
-                                .expect_err("local object is absent");
-                            assert_eq!(*head_error.code(), S3ErrorCode::NoSuchKey);
-                            let listing = tokio::time::timeout(
-                                Duration::from_secs(10),
-                                DefaultBucketUsecase::from_global().execute_list_objects_v2(list),
-                            )
-                            .await
-                            .expect("LIST stays local")
-                            .expect("replacement bucket lists locally");
-                            assert_eq!(listing.output.key_count, Some(0));
-                        }
-                    }
-                    stop.cancel();
-                    assert!(server.await.expect("source server must remain unused").is_empty());
-                },
-            )
-            .await;
-        });
-    }
-
-    #[test]
-    #[serial_test::serial]
-    fn list_objects_v1_stays_local_with_xml_safe_key_markers() {
-        run_large_stack_test("list-through-v1-local-markers", || async {
-            temp_env::async_with_vars(
-                [
-                    ("RUSTFS_REPLICATION_ALLOW_LOOPBACK_TARGET", Some("true")),
-                    ("HTTP_PROXY", None),
-                    ("HTTPS_PROXY", None),
-                    ("ALL_PROXY", None),
-                    ("http_proxy", None),
-                    ("https_proxy", None),
-                    ("all_proxy", None),
-                    ("NO_PROXY", Some("*")),
-                    ("no_proxy", Some("*")),
-                ],
-                async {
-                    let (endpoint, server, stop) =
-                        list_source(std::iter::repeat(source_xml(None, false, Some("a-source")))).await;
-                    let (_state_guard, source_input) =
-                        source_policy_input(endpoint, SourceErrorPolicy::Propagate, None, None).await;
-                    let store = shared_gating_ecstore().await;
-                    store
-                        .put_object(
-                            &source_input.bucket,
-                            "a&local",
-                            &mut StoragePutObjReader::from_vec(vec![1]),
-                            &StorageObjectOptions::default(),
-                        )
-                        .await
-                        .expect("seed a second local object");
-
-                    for delimiter in [None, Some("/".to_string())] {
-                        let mut input = ListObjectsInput {
-                            bucket: source_input.bucket.clone(),
-                            max_keys: Some(1),
-                            delimiter,
-                            ..Default::default()
-                        };
-                        for (index, expected_key) in ["a&local", "z-local"].into_iter().enumerate() {
-                            let request_marker = input.marker.clone().unwrap_or_default();
-                            let response = tokio::time::timeout(
-                                Duration::from_secs(10),
-                                DefaultBucketUsecase::from_global().execute_list_objects(S3Request {
-                                    input: input.clone(),
-                                    method: http::Method::GET,
-                                    uri: http::Uri::from_static("/"),
-                                    headers: HeaderMap::new(),
-                                    extensions: http::Extensions::new(),
-                                    credentials: None,
-                                    region: None,
-                                    service: None,
-                                    trailing_headers: None,
-                                }),
-                            )
-                            .await
-                            .expect("v1 pagination must finish")
-                            .expect("list-through must not change v1 listing");
-                            assert!(!response.headers.contains_key("x-rustfs-on-demand-migration-list"));
-                            let output = response.output;
-                            let contents = output.contents.as_ref().expect("local page contents");
-                            assert_eq!(contents.len(), 1);
-                            assert_eq!(contents[0].key.as_deref(), Some(expected_key));
-                            assert_eq!(output.marker.as_deref(), Some(request_marker.as_str()));
-                            assert_eq!(output.is_truncated, Some(index == 0));
-                            assert_eq!(output.next_marker.as_deref(), (index == 0).then_some(expected_key));
-
-                            let mut xml = Vec::new();
-                            XmlSerialize::serialize(&output, &mut XmlSerializer::new(&mut xml))
-                                .expect("serialize the real v1 response");
-                            assert!(!xml.contains(&0), "XML 1.0 forbids NUL in NextMarker");
-                            let mut reader = quick_xml::Reader::from_reader(xml.as_slice());
-                            loop {
-                                if reader.read_event().expect("v1 response must be well-formed XML")
-                                    == quick_xml::events::Event::Eof
-                                {
-                                    break;
-                                }
-                            }
-                            input.marker = output.next_marker;
-                        }
-                    }
-                    stop.cancel();
-                    let requests = server.await.expect("source server must not panic");
-                    assert!(requests.is_empty(), "ListObjects v1 must issue no remote LIST requests: {requests:?}");
-                },
-            )
-            .await;
-        });
-    }
-
     #[test]
     #[serial_test::serial]
     fn list_through_invalid_source_pagination_obeys_policy_on_the_handler_path() {

rustfs/src/app/bucket_usecase.rs

@@ -20,7 +20,7 @@ use super::storage_api::bucket_usecase::StorageObjectInfo as ObjectInfo;
 use super::storage_api::bucket_usecase::access::ReqInfo;
 use super::storage_api::bucket_usecase::access::{
     authorize_request, bucket_config_mutation_incarnation, log_list_buckets_iam_implicit_deny,
-    prepare_list_buckets_iam_authorization, prepare_odm_read_generation, req_info_ref,
+    prepare_list_buckets_iam_authorization, req_info_ref,
 };
 #[cfg(test)]
 use super::storage_api::bucket_usecase::bucket::target::BucketTarget;
@@ -2724,14 +2724,7 @@ impl DefaultBucketUsecase {
 
     #[instrument(level = "trace", skip(self, req))]
     pub async fn execute_list_objects_v2(&self, req: S3Request<ListObjectsV2Input>) -> S3Result<S3Response<ListObjectsV2Output>> {
-        self.execute_list_objects_v2_inner(req, true).await
-    }
-
-    async fn execute_list_objects_v2_inner(
-        &self,
-        mut req: S3Request<ListObjectsV2Input>,
-        allow_list_through: bool,
-    ) -> S3Result<S3Response<ListObjectsV2Output>> {
+        // warn!("list_objects_v2 req {:?}", &req.input);
         let ListObjectsV2Input {
             bucket,
             continuation_token,
@@ -2742,7 +2735,7 @@ impl DefaultBucketUsecase {
             prefix,
             start_after,
             ..
-        } = req.input.clone();
+        } = req.input;
 
         let params = parse_list_objects_v2_params(prefix, delimiter, max_keys, continuation_token, start_after)?;
 
@@ -2757,18 +2750,8 @@ impl DefaultBucketUsecase {
         // The on-demand migration envelope is decoded whether or not this
         // bucket still merges: a token handed out under `list_through` must keep
         // paginating after the policy is turned off (rustfs/backlog#2164).
-        if allow_list_through {
-            prepare_odm_read_generation(&store, &mut req, &bucket).await;
-        }
-        let (merged_token, source_state) = if allow_list_through {
-            (
-                list_through::decode_list_cursor(params.decoded_continuation_token.as_deref())?,
-                list_through::list_through_state(&store, &bucket, &req, &params).await?,
-            )
-        } else {
-            (None, None)
-        };
-        let (object_infos, degraded) = match source_state {
+        let merged_token = list_through::decode_list_cursor(params.decoded_continuation_token.as_deref())?;
+        let (object_infos, degraded) = match list_through::list_through_state(&bucket, &req.headers) {
             Some(state) => {
                 let outcome = list_through::merged_list_objects_v2(
                     &store,
@@ -2955,9 +2938,7 @@ impl DefaultBucketUsecase {
     #[instrument(level = "debug", skip(self, req))]
     pub async fn execute_list_objects(&self, req: S3Request<ListObjectsInput>) -> S3Result<S3Response<ListObjectsOutput>> {
         let request_marker = req.input.marker.clone();
-        // V1 markers are object keys, so they cannot carry the opaque merged
-        // pagination state used by V2 list-through.
-        let v2_resp = self.execute_list_objects_v2_inner(req.map_input(Into::into), false).await?;
+        let v2_resp = self.execute_list_objects_v2(req.map_input(Into::into)).await?;
 
         Ok(v2_resp.map_output(|v2| build_list_objects_output(v2, request_marker)))
     }

rustfs/src/app/object/get.rs

@@ -15,11 +15,11 @@
 //! GetObject / GetObjectAttributes read path: cold fill, resume, stream tuning.
 
 use super::*;
-use crate::on_demand_migration::WriteBackBody;
-use crate::on_demand_migration::{
+use crate::app::storage_api::object_usecase::bucket::on_demand_migration::{
     BucketOdmState, OdmLookup, OdmOp, OdmOutcome, OnDemandMigrationSys, PullError, PullLeader, PullOutcome, PullReason, PullSlot,
     RangeGetPolicy, SourceBody, SourceClient, SourceError, SourceGet, SourceHead, commit_inline, idle_guarded_body,
 };
+use crate::app::storage_api::object_usecase::on_demand_migration::WriteBackBody;
 use rustfs_rio::{TeeOptions, TeePrimary, tee_reader_with_options};
 use tokio_stream::wrappers::ReceiverStream;
 
@@ -3843,11 +3843,11 @@ impl DefaultObjectUsecase {
         if !odm_get_may_consult_source(opts, part_number) {
             return None;
         }
-        let sys = OnDemandMigrationSys::get();
-        if !sys.is_module_enabled() {
-            return None;
-        }
-        let state = sys.state(bucket).filter(|state| state.matches_prefix(key))?;
+        let lookup = OnDemandMigrationSys::get().resolve(bucket, key)?;
+        let (state, client) = match odm_get_verdict(lookup) {
+            OdmGetVerdict::Fail(err) => return Some(OdmGetOutcome::Respond(Err(err))),
+            OdmGetVerdict::Consult { state, client } => (state, client),
+        };
         let policy = &state.config().policy;
         // The read path reports a latest delete marker as a plain 404, so the
         // marker is classified here, and only where one can exist.
@@ -3861,24 +3861,6 @@ impl DefaultObjectUsecase {
                 None => return Some(OdmGetOutcome::RetryLocal),
             }
         }
-        let expected_incarnation = match odm_read_generation(req, bucket) {
-            Ok(Some(incarnation)) => incarnation,
-            Ok(None) => return None,
-            Err(err) => return Some(OdmGetOutcome::Respond(Err(err))),
-        };
-        match store.bucket_incarnation_id(bucket).await {
-            Ok(current) if current == expected_incarnation => {}
-            Ok(_) => return None,
-            Err(err) => return Some(OdmGetOutcome::Respond(Err(ApiError::from(err).into()))),
-        }
-        if !sys.is_module_enabled() {
-            return None;
-        }
-        let lookup = state.filter_incarnation(expected_incarnation)?.resolve_key(key)?;
-        let (state, client) = match odm_get_verdict(lookup) {
-            OdmGetVerdict::Fail(err) => return Some(OdmGetOutcome::Respond(Err(err))),
-            OdmGetVerdict::Consult { state, client } => (state, client),
-        };
         let request_context = req.extensions.get::<request_context::RequestContext>().cloned();
         let reply = odm_get_from_source(&state, client.as_ref(), &req.headers, key, range, request_context).await;
         Some(match reply {
@@ -3913,7 +3895,7 @@ impl DefaultObjectUsecase {
         result
     }
 
-    async fn execute_get_object_inner(&self, mut req: S3Request<GetObjectInput>) -> S3Result<S3Response<GetObjectOutput>> {
+    async fn execute_get_object_inner(&self, req: S3Request<GetObjectInput>) -> S3Result<S3Response<GetObjectOutput>> {
         let helper = OperationHelper::new(&req, EventName::ObjectAccessedGet, S3Operation::GetObject).suppress_event();
 
         if let Some(context) = &self.context {
@@ -3999,8 +3981,6 @@ impl DefaultObjectUsecase {
                 return Self::complete_get_object_error(helper, err);
             }
         };
-        let bucket = req.input.bucket.clone();
-        prepare_odm_read_generation(&store, &mut req, &bucket).await;
         if let Some(request_context_start) = request_context_start {
             rustfs_io_metrics::record_get_object_stage_duration(
                 "s3_handler",
@@ -4818,11 +4798,11 @@ pub(super) async fn odm_get_from_source<S: OdmGetSource>(
 #[cfg(test)]
 mod on_demand_migration_tests {
     use super::*;
-    use crate::on_demand_migration::{
+    use crate::app::storage_api::object_usecase::bucket::on_demand_migration::{
         BREAKER_FAILURE_THRESHOLD, BreakerState, FilterConfig, OdmStateError, OnDemandMigrationConfig, PathStyle, PolicyConfig,
         Provider, SourceConfig, SourceCredentials, SourceErrorPolicy, TlsConfig,
     };
-    use crate::on_demand_migration::{
+    use crate::app::storage_api::object_usecase::on_demand_migration::{
         LocalObject, OdmWriteBack, WriteBackError, WriteBackOutcome, WriteBackPart, WriteBackRequest,
     };
     use async_trait::async_trait;
@@ -4939,7 +4919,7 @@ mod on_demand_migration_tests {
             Err(WriteBackError::Local("multipart is not part of the inline path".to_string()))
         }
 
-        async fn abort_multipart_upload(&self, _request: &WriteBackRequest, _upload_id: &str) -> Result<(), WriteBackError> {
+        async fn abort_multipart_upload(&self, _bucket: &str, _key: &str, _upload_id: &str) -> Result<(), WriteBackError> {
             Ok(())
         }
     }

rustfs/src/app/object/head.rs

@@ -15,7 +15,7 @@
 //! HeadObject path.
 
 use super::*;
-use crate::on_demand_migration::{
+use crate::app::storage_api::object_usecase::bucket::on_demand_migration::{
     BucketOdmState, HeadPolicy, OdmLookup, OdmOp, OdmOutcome, OnDemandMigrationSys, SourceClient, SourceError, SourceHead,
 };
 
@@ -146,8 +146,6 @@ impl DefaultObjectUsecase {
     /// `None` means the runtime does not intervene and the caller keeps its
     /// original 404. The source answer is never written back or queued.
     async fn on_demand_migration_head(
-        req: &S3Request<HeadObjectInput>,
-        store: &ECStore,
         bucket: &str,
         key: &str,
         opts: &ObjectOptions,
@@ -156,33 +154,7 @@ impl DefaultObjectUsecase {
         if !odm_request_may_consult_source(opts) {
             return None;
         }
-        let sys = OnDemandMigrationSys::get();
-        if !sys.is_module_enabled() {
-            return None;
-        }
-        let state = sys.state(bucket).filter(|state| state.matches_prefix(key))?;
-        let policy = &state.config().policy;
-        if !odm_policy_admits_miss(policy, miss) {
-            return None;
-        }
-        if policy.head == HeadPolicy::LocalOnly {
-            state.stats().record_request(OdmOp::Head, OdmOutcome::Filtered);
-            return None;
-        }
-        let expected_incarnation = match odm_read_generation(req, bucket) {
-            Ok(Some(incarnation)) => incarnation,
-            Ok(None) => return None,
-            Err(err) => return Some(Err(err)),
-        };
-        match store.bucket_incarnation_id(bucket).await {
-            Ok(current) if current == expected_incarnation => {}
-            Ok(_) => return None,
-            Err(err) => return Some(Err(ApiError::from(err).into())),
-        }
-        if !sys.is_module_enabled() {
-            return None;
-        }
-        let lookup = state.filter_incarnation(expected_incarnation)?.resolve_key(key)?;
+        let lookup = OnDemandMigrationSys::get().resolve(bucket, key)?;
         match odm_head_verdict(lookup, miss) {
             OdmHeadVerdict::Ignore => None,
             OdmHeadVerdict::Fail(err) => Some(Err(err)),
@@ -297,7 +269,7 @@ impl DefaultObjectUsecase {
     }
 
     #[instrument(level = "debug", skip(self, req))]
-    pub async fn execute_head_object(&self, mut req: S3Request<HeadObjectInput>) -> S3Result<S3Response<HeadObjectOutput>> {
+    pub async fn execute_head_object(&self, req: S3Request<HeadObjectInput>) -> S3Result<S3Response<HeadObjectOutput>> {
         if let Some(context) = &self.context {
             let _ = context.object_store();
         }
@@ -342,8 +314,6 @@ impl DefaultObjectUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        prepare_odm_read_generation(&store, &mut req, &bucket).await;
-
         // Modification Points: Explicitly handles get_object_info errors, distinguishing between object absence and other errors
         let lookup = store.get_object_info(&bucket, &key, &opts).await;
         // Single classification point for the on-demand migration gate
@@ -377,7 +347,7 @@ impl DefaultObjectUsecase {
                         return result;
                     }
                     if let Some(miss) = odm_miss
-                        && let Some(result) = Self::on_demand_migration_head(&req, &store, &bucket, &key, &opts, miss).await
+                        && let Some(result) = Self::on_demand_migration_head(&bucket, &key, &opts, miss).await
                     {
                         return Self::finish_on_demand_migration_head(&req, &bucket, helper, result?).await;
                     }
@@ -392,7 +362,7 @@ impl DefaultObjectUsecase {
                 // A latest delete marker is a local miss the source may still
                 // answer when the bucket policy says so.
                 if let Some(miss) = odm_miss
-                    && let Some(result) = Self::on_demand_migration_head(&req, &store, &bucket, &key, &opts, miss).await
+                    && let Some(result) = Self::on_demand_migration_head(&bucket, &key, &opts, miss).await
                 {
                     return Self::finish_on_demand_migration_head(&req, &bucket, helper, result?).await;
                 }
@@ -668,7 +638,7 @@ impl DefaultObjectUsecase {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::on_demand_migration::{
+    use crate::app::storage_api::object_usecase::bucket::on_demand_migration::{
         BREAKER_FAILURE_THRESHOLD, BreakerState, FilterConfig, OdmStateError, OnDemandMigrationConfig, PathStyle, PolicyConfig,
         Provider, SourceConfig, SourceCredentials, SourceErrorPolicy, TlsConfig,
     };
@@ -769,9 +739,11 @@ mod tests {
             user_metadata: HashMap::from([("owner".to_string(), "alice".to_string())]),
             version_id: Some("v1".to_string()),
             storage_class: Some("STANDARD_IA".to_string()),
-            sse: Some(crate::on_demand_migration::source_client::SourceSse::Kms {
-                key_id: Some("key-1".to_string()),
-            }),
+            sse: Some(
+                crate::storage::storage_api::ecstore_bucket::on_demand_migration::source_client::SourceSse::Kms {
+                    key_id: Some("key-1".to_string()),
+                },
+            ),
             is_multipart_etag: true,
             etag_is_opaque: false,
         }
@@ -1083,12 +1055,7 @@ mod tests {
             head: HeadPolicy::LocalOnly,
             ..Default::default()
         });
-        sys.apply_for_incarnation(
-            &bucket,
-            store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-            Some(&cfg),
-        )
-        .await;
+        sys.apply(&bucket, Some(&cfg)).await;
         let state = sys.state(&bucket).expect("bucket runtime installed");
 
         // Local hit: served locally, the runtime is never entered.
@@ -1144,12 +1111,7 @@ mod tests {
         );
 
         cfg.policy.respect_local_delete_marker = false;
-        sys.apply_for_incarnation(
-            &bucket,
-            store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-            Some(&cfg),
-        )
-        .await;
+        sys.apply(&bucket, Some(&cfg)).await;
         let err = Box::pin(usecase.execute_head_object(head_input(&bucket, "present", None)))
             .await
             .expect_err("local_only still answers 404");

rustfs/src/app/object/internal_put.rs

@@ -48,8 +48,6 @@ use http::HeaderName;
 /// other internal provenance is written verbatim.
 pub(crate) struct InternalPutContext {
     pub(crate) bucket: String,
-    /// Pins background work to its original bucket across deletion and recreation.
-    pub(crate) expected_bucket_incarnation_id: Option<Uuid>,
     pub(crate) key: String,
     /// Plaintext object length. The single-object path requires it, exactly
     /// like S3 PutObject rejects an unknown `Content-Length`.
@@ -241,7 +239,6 @@ impl DefaultObjectUsecase {
         let start_time = Instant::now();
         let InternalPutContext {
             bucket,
-            expected_bucket_incarnation_id,
             key,
             size,
             expected_md5_hex,
@@ -299,7 +296,6 @@ impl DefaultObjectUsecase {
                 principal_id,
                 emit_events,
                 preserve_delete_marker,
-                expected_bucket_incarnation_id,
             },
         };
         let committed = self
@@ -371,8 +367,6 @@ impl DefaultObjectUsecase {
             .await
             .map_err(ApiError::from)?;
 
-        opts.expected_bucket_incarnation_id = ctx.expected_bucket_incarnation_id;
-
         let dsc = must_replicate_object(
             &ctx.bucket,
             &ctx.key,
@@ -434,10 +428,7 @@ impl DefaultObjectUsecase {
         let bucket = ctx.bucket.as_str();
         let key = ctx.key.as_str();
         let store = self.object_store().ok_or_else(not_initialized)?;
-        let mut opts = ObjectOptions {
-            expected_bucket_incarnation_id: ctx.expected_bucket_incarnation_id,
-            ..Default::default()
-        };
+        let mut opts = ObjectOptions::default();
         let session = store
             .get_multipart_info(bucket, key, upload_id, &opts)
             .await
@@ -551,7 +542,6 @@ impl DefaultObjectUsecase {
         }
         let mut opts =
             get_complete_multipart_upload_opts_with_replication_authorization(&headers, false).map_err(ApiError::from)?;
-        opts.expected_bucket_incarnation_id = ctx.expected_bucket_incarnation_id;
         opts.preserve_etag = ctx.preserve_etag.clone();
         opts.preserve_delete_marker = ctx.preserve_delete_marker;
         let versioned = BucketVersioningSys::prefix_enabled(&bucket, &key).await;
@@ -709,24 +699,10 @@ impl DefaultObjectUsecase {
     }
 
     /// Discard an internal multipart upload and its staged parts.
-    pub(crate) async fn internal_abort_multipart_upload(
-        &self,
-        bucket: &str,
-        key: &str,
-        upload_id: &str,
-        expected_bucket_incarnation_id: Option<Uuid>,
-    ) -> Result<(), ApiError> {
+    pub(crate) async fn internal_abort_multipart_upload(&self, bucket: &str, key: &str, upload_id: &str) -> Result<(), ApiError> {
         let store = self.object_store().ok_or_else(not_initialized)?;
         store
-            .abort_multipart_upload(
-                bucket,
-                key,
-                upload_id,
-                &ObjectOptions {
-                    expected_bucket_incarnation_id,
-                    ..Default::default()
-                },
-            )
+            .abort_multipart_upload(bucket, key, upload_id, &ObjectOptions::default())
             .await
             .map_err(ApiError::from)?;
         rustfs_scanner::record_dirty_usage_bucket(bucket);
@@ -780,7 +756,6 @@ mod tests {
     fn internal_context(bucket: &str, key: &str, body: &[u8]) -> InternalPutContext {
         InternalPutContext {
             bucket: bucket.to_string(),
-            expected_bucket_incarnation_id: None,
             key: key.to_string(),
             size: Some(body.len() as u64),
             expected_md5_hex: Some(md5_hex(body)),
@@ -1163,14 +1138,9 @@ mod tests {
         ))
         .await
         .expect("part of the aborted upload must stage");
-        Box::pin(usecase.internal_abort_multipart_upload(
-            &bucket,
-            &ctx.key,
-            &aborted_upload_id,
-            ctx.expected_bucket_incarnation_id,
-        ))
-        .await
-        .expect("internal abort must succeed");
+        Box::pin(usecase.internal_abort_multipart_upload(&bucket, &ctx.key, &aborted_upload_id))
+            .await
+            .expect("internal abort must succeed");
         let uploads = Box::pin(store.list_multipart_uploads(&bucket, &ctx.key, None, None, None, 100))
             .await
             .expect("list multipart uploads after abort");

rustfs/src/app/object/mod.rs

@@ -21,8 +21,8 @@ use crate::storage_api::table::get_bucket_metadata;
 
 use super::storage_api::object_usecase::access::{
     PostObjectRequestMarker, apply_bucket_generation_guard, apply_copy_source_bucket_generation_guard, authorize_request,
-    has_bypass_governance_header, load_bucket_generation_from_store, odm_read_generation, prepare_odm_read_generation,
-    recursive_force_delete_is_authorized, replication_request_authorized, req_info_mut, req_info_ref,
+    has_bypass_governance_header, load_bucket_generation_from_store, recursive_force_delete_is_authorized,
+    replication_request_authorized, req_info_mut, req_info_ref,
 };
 #[cfg(test)]
 use super::storage_api::object_usecase::bucket::quota::BucketQuota;

rustfs/src/app/object/on_demand_migration_put.rs

@@ -13,7 +13,7 @@
 // limitations under the License.
 
 //! On-demand migration write-back (rustfs/backlog#2153): the app-layer
-//! [`OdmWriteBack`] the migration service stores source objects with.
+//! [`OdmWriteBack`] the ecstore pull pipeline stores source objects with.
 //!
 //! Every write goes through the internal put entry points, so a pulled
 //! object is indistinguishable from a client PUT: bucket default SSE, quota,
@@ -34,7 +34,7 @@
 use super::*;
 
 use crate::app::storage_api::multipart_usecase::contract::multipart::CompletePart;
-use crate::on_demand_migration::{
+use crate::app::storage_api::object_usecase::on_demand_migration::{
     LocalObject, OdmWriteBack, SourceHead, WriteBackBody, WriteBackError, WriteBackOutcome, WriteBackPart, WriteBackRequest,
     is_multipart_etag,
 };
@@ -172,7 +172,6 @@ pub(super) async fn write_back_context(request: &WriteBackRequest, single_part:
     };
     InternalPutContext {
         bucket: request.bucket.clone(),
-        expected_bucket_incarnation_id: Some(request.bucket_incarnation_id),
         key: request.key.clone(),
         size: Some(head.size),
         expected_md5_hex: single_part.then(|| expected_md5_hex(head)).flatten(),
@@ -286,9 +285,9 @@ impl OdmWriteBack for OnDemandMigrationWriteBack {
             .map_err(write_back_error)
     }
 
-    async fn abort_multipart_upload(&self, request: &WriteBackRequest, upload_id: &str) -> Result<(), WriteBackError> {
+    async fn abort_multipart_upload(&self, bucket: &str, key: &str, upload_id: &str) -> Result<(), WriteBackError> {
         self.usecase()
-            .internal_abort_multipart_upload(&request.bucket, &request.key, upload_id, Some(request.bucket_incarnation_id))
+            .internal_abort_multipart_upload(bucket, key, upload_id)
             .await
             .map_err(write_back_error)
     }
@@ -298,15 +297,15 @@ impl OdmWriteBack for OnDemandMigrationWriteBack {
 mod tests {
     use super::*;
     use crate::app::storage_api::multipart_usecase::contract::multipart::MultipartOperations as _;
+    use crate::app::storage_api::object_usecase::on_demand_migration::{PullFailureReason, SourceSse};
     use crate::app::storage_api::s3::{
         BucketVersioningStatus, DeleteMarkerReplication, DeleteMarkerReplicationStatus, Destination, ReplicationConfiguration,
         ReplicationRule, ReplicationRuleFilter, ReplicationRuleStatus, ServerSideEncryptionByDefault,
         ServerSideEncryptionConfiguration, ServerSideEncryptionRule, Tag, VersioningConfiguration,
     };
     use crate::app::storage_api::test::bucket::utils::serialize;
-    use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, DeleteBucketOptions, MakeBucketOptions};
+    use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, MakeBucketOptions};
     use crate::app::storage_api::test::{get_global_bucket_metadata_sys, set_bucket_metadata};
-    use crate::on_demand_migration::{PullFailureReason, SourceSse};
     use http::Method;
     use rustfs_utils::http::{MINIO_INTERNAL_PREFIX, RUSTFS_INTERNAL_PREFIX, contains_key_str, get_str};
     use sha2::{Digest as Sha256Digest, Sha256};
@@ -346,10 +345,9 @@ mod tests {
         }
     }
 
-    fn request(bucket: &str, bucket_incarnation_id: Uuid, key: &str, head: SourceHead) -> WriteBackRequest {
+    fn request(bucket: &str, key: &str, head: SourceHead) -> WriteBackRequest {
         WriteBackRequest {
             bucket: bucket.to_string(),
-            bucket_incarnation_id,
             key: key.to_string(),
             head,
             source_label: SOURCE_LABEL.to_string(),
@@ -477,15 +475,7 @@ mod tests {
         let body = b"pulled from the legacy bucket".to_vec();
         let head = source_head(&body);
         let outcome = write_back
-            .put_object(
-                &request(
-                    &bucket,
-                    store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                    "dir/obj.txt",
-                    head.clone(),
-                ),
-                body_stream(&body),
-            )
+            .put_object(&request(&bucket, "dir/obj.txt", head.clone()), body_stream(&body))
             .await
             .expect("write-back must commit");
         assert_eq!(outcome.etag, head.etag, "single-part source ETag is preserved");
@@ -528,12 +518,7 @@ mod tests {
             .await
             .expect("bucket");
         let write_back = OnDemandMigrationWriteBack::new();
-        let req = request(
-            bucket,
-            store.bucket_incarnation_id(bucket).await.expect("bucket incarnation"),
-            "key",
-            source_head(b"source"),
-        );
+        let req = request(bucket, "key", source_head(b"source"));
         assert!(matches!(
             write_back.put_object(&req, body_stream(b"source")).await,
             Err(WriteBackError::Unsupported(_))
@@ -549,75 +534,6 @@ mod tests {
         assert_nothing_left(&store, bucket, "key").await;
     }
 
-    #[tokio::test]
-    #[serial_test::serial]
-    async fn stale_write_back_cannot_mutate_a_recreated_bucket() {
-        let (store, bucket) = write_back_test_bucket("odm-wb-incarnation", false).await;
-        let old_id = store.bucket_incarnation_id(&bucket).await.expect("old bucket incarnation");
-        let stale = request(&bucket, old_id, "object", source_head(b"source"));
-        let (resume, wait) = tokio::sync::oneshot::channel();
-        let delayed = {
-            let stale = stale.clone();
-            tokio::spawn(async move {
-                wait.await.expect("resume old source pull");
-                OnDemandMigrationWriteBack::new()
-                    .put_object(&stale, body_stream(b"source"))
-                    .await
-            })
-        };
-        store
-            .delete_bucket(
-                &bucket,
-                &DeleteBucketOptions {
-                    force: true,
-                    ..Default::default()
-                },
-            )
-            .await
-            .expect("delete original bucket");
-        store
-            .make_bucket(&bucket, &MakeBucketOptions::default())
-            .await
-            .expect("recreate bucket");
-        let new_id = store.bucket_incarnation_id(&bucket).await.expect("replacement incarnation");
-        assert_ne!(old_id, new_id);
-        resume.send(()).expect("release delayed pull");
-        assert!(delayed.await.expect("delayed pull task").is_err());
-        assert_nothing_left(&store, &bucket, "object").await;
-
-        let write_back = OnDemandMigrationWriteBack::new();
-        assert!(write_back.create_multipart_upload(&stale).await.is_err());
-        let current = request(&bucket, new_id, "object", source_head(b"current"));
-        let upload = write_back
-            .create_multipart_upload(&current)
-            .await
-            .expect("create replacement upload");
-        // A stale capability must fail independently of whether its upload ID
-        // happens to name a valid session in the replacement bucket.
-        assert!(
-            write_back
-                .upload_part(&stale, &upload, 1, 6, body_stream(b"source"))
-                .await
-                .is_err()
-        );
-        let part = write_back
-            .upload_part(&current, &upload, 1, 7, body_stream(b"current"))
-            .await
-            .expect("stage current part");
-        assert!(
-            write_back
-                .complete_multipart_upload(&stale, &upload, vec![part.clone()])
-                .await
-                .is_err()
-        );
-        assert!(write_back.abort_multipart_upload(&stale, &upload).await.is_err());
-        write_back
-            .complete_multipart_upload(&current, &upload, vec![part])
-            .await
-            .expect("stale cleanup preserves replacement upload");
-        assert_eq!(raw_object_bytes(&store, &bucket, "object").await, b"current");
-    }
-
     #[tokio::test]
     #[serial_test::serial]
     async fn write_back_integrity_failure_leaves_nothing_behind() {
@@ -627,15 +543,7 @@ mod tests {
         head.etag = Some(md5_hex(b"a different body"));
 
         let err = OnDemandMigrationWriteBack::new()
-            .put_object(
-                &request(
-                    &bucket,
-                    store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                    "wrong.bin",
-                    head,
-                ),
-                body_stream(&body),
-            )
+            .put_object(&request(&bucket, "wrong.bin", head), body_stream(&body))
             .await
             .expect_err("an ETag mismatch must fail the write-back");
         assert_eq!(err, WriteBackError::Integrity);
@@ -651,18 +559,8 @@ mod tests {
             let (store, bucket) = write_back_test_bucket("odm-wb-race", versioned).await;
             let source = b"old source bytes";
             let client = b"new client bytes";
-            let req = request(
-                &bucket,
-                store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                "race",
-                source_head(source),
-            );
-            let client_req = request(
-                &bucket,
-                store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                "race",
-                source_head(client),
-            );
+            let req = request(&bucket, "race", source_head(source));
+            let client_req = request(&bucket, "race", source_head(client));
             let mut client_ctx = write_back_context(&client_req, true).await;
             client_ctx.if_absent = false;
             let client_after = PutObjectCommitBarrier::install(&bucket, "race", PutObjectCommitPause::AfterNamespace);
@@ -697,27 +595,13 @@ mod tests {
     async fn write_back_multipart_completion_preserves_a_client_put_after_staging() {
         let (store, bucket) = write_back_test_bucket("odm-mpu-race", false).await;
         let write_back = OnDemandMigrationWriteBack::new();
-        let req = request(
-            &bucket,
-            store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-            "race",
-            source_head(b"source"),
-        );
+        let req = request(&bucket, "race", source_head(b"source"));
         let upload_id = write_back.create_multipart_upload(&req).await.expect("create");
         let part = write_back
             .upload_part(&req, &upload_id, 1, 6, body_stream(b"source"))
             .await
             .expect("stage");
-        let mut client_ctx = write_back_context(
-            &request(
-                &bucket,
-                store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                "race",
-                source_head(b"client"),
-            ),
-            true,
-        )
-        .await;
+        let mut client_ctx = write_back_context(&request(&bucket, "race", source_head(b"client")), true).await;
         client_ctx.if_absent = false;
         let committed = DefaultObjectUsecase::from_global()
             .internal_put_object(client_ctx, body_stream(b"client"))
@@ -729,7 +613,7 @@ mod tests {
             "{result:?}"
         );
         write_back
-            .abort_multipart_upload(&req, &upload_id)
+            .abort_multipart_upload(&bucket, "race", &upload_id)
             .await
             .expect("abort rejected upload");
         let stored = stored_object(&store, &bucket, "race").await;
@@ -744,12 +628,7 @@ mod tests {
         for multipart in [false, true] {
             let (store, bucket) = write_back_test_bucket("odm-wb-tombstone", true).await;
             let write_back = OnDemandMigrationWriteBack::new();
-            let mut req = request(
-                &bucket,
-                store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                "deleted",
-                source_head(b"source"),
-            );
+            let mut req = request(&bucket, "deleted", source_head(b"source"));
             let staged = if multipart {
                 let id = write_back.create_multipart_upload(&req).await.expect("create");
                 let part = write_back
@@ -775,7 +654,10 @@ mod tests {
             assert!(marker.delete_marker);
             let rejected = if let Some((id, part)) = staged {
                 let result = write_back.complete_multipart_upload(&req, &id, vec![part]).await;
-                write_back.abort_multipart_upload(&req, &id).await.expect("abort");
+                write_back
+                    .abort_multipart_upload(&bucket, "deleted", &id)
+                    .await
+                    .expect("abort");
                 result
             } else {
                 write_back.put_object(&req, body_stream(b"source")).await
@@ -809,15 +691,7 @@ mod tests {
             Err(io::Error::new(io::ErrorKind::BrokenPipe, "tee primary dropped before EOF")),
         ]);
         let err = OnDemandMigrationWriteBack::new()
-            .put_object(
-                &request(
-                    &bucket,
-                    store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                    "torn.bin",
-                    head.clone(),
-                ),
-                torn,
-            )
+            .put_object(&request(&bucket, "torn.bin", head.clone()), torn)
             .await
             .expect_err("a broken stream must fail the write-back");
         assert_ne!(err, WriteBackError::Integrity, "{err}");
@@ -826,15 +700,7 @@ mod tests {
         // A clean EOF short of the advertised size is just as fatal.
         let short = stream(vec![Ok(Bytes::copy_from_slice(&body[..64 * 1024]))]);
         let err = OnDemandMigrationWriteBack::new()
-            .put_object(
-                &request(
-                    &bucket,
-                    store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                    "short.bin",
-                    head,
-                ),
-                short,
-            )
+            .put_object(&request(&bucket, "short.bin", head), short)
             .await
             .expect_err("a short body must fail the write-back");
         assert!(matches!(err, WriteBackError::Local(_) | WriteBackError::Integrity), "{err}");
@@ -850,12 +716,7 @@ mod tests {
         let mut head = source_head(&body);
         head.etag = Some(format!("{}-2", md5_hex(&body)));
         head.is_multipart_etag = true;
-        let request = request(
-            &bucket,
-            store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-            "big/object.bin",
-            head.clone(),
-        );
+        let request = request(&bucket, "big/object.bin", head.clone());
         let write_back = OnDemandMigrationWriteBack::new();
 
         let upload_id = write_back.create_multipart_upload(&request).await.expect("create");
@@ -893,7 +754,10 @@ mod tests {
             .upload_part(&request, &aborted, 1, 4096, body_stream(&body[..4096]))
             .await
             .expect("stage part");
-        write_back.abort_multipart_upload(&request, &aborted).await.expect("abort");
+        write_back
+            .abort_multipart_upload(&bucket, "big/object.bin", &aborted)
+            .await
+            .expect("abort");
         let uploads = store
             .list_multipart_uploads(&bucket, "big/object.bin", None, None, None, 100)
             .await
@@ -946,12 +810,7 @@ mod tests {
 
             let body = b"plaintext that must be encrypted at rest".to_vec();
             let head = source_head(&body);
-            let request = request(
-                &bucket,
-                store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                "secret.txt",
-                head.clone(),
-            );
+            let request = request(&bucket, "secret.txt", head.clone());
             // The source ETag is not forced onto an encrypted object; the
             // local ETag is whatever the SSE write path computes.
             assert_eq!(write_back_context(&request, true).await.preserve_etag, None);
@@ -989,15 +848,7 @@ mod tests {
         let (store, bucket) = crate::app::gating_test_env::durable_quota_test_bucket("odm-wb-quota", 64).await;
         let body = vec![0x71; 4096];
         let err = OnDemandMigrationWriteBack::new()
-            .put_object(
-                &request(
-                    &bucket,
-                    store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-                    "over.bin",
-                    source_head(&body),
-                ),
-                body_stream(&body),
-            )
+            .put_object(&request(&bucket, "over.bin", source_head(&body)), body_stream(&body))
             .await
             .expect_err("a full quota must reject the write-back");
         assert!(matches!(err, WriteBackError::Quota(_)), "{err}");
@@ -1062,12 +913,7 @@ mod tests {
 
         let body = b"replicate me".to_vec();
         let head = source_head(&body);
-        let request = request(
-            &bucket,
-            store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-            "replicated.txt",
-            head,
-        );
+        let request = request(&bucket, "replicated.txt", head);
         let ctx = write_back_context(&request, true).await;
         assert!(ctx.emit_events, "policy.emit_events reaches the creation event");
         assert_eq!(ctx.principal_id, ON_DEMAND_MIGRATION_PRINCIPAL_ID);
@@ -1115,12 +961,7 @@ mod tests {
         head.user_metadata
             .insert(forged_replica_key.to_string(), ReplicationStatusType::Replica.as_str().to_string());
 
-        let mut write_request = request(
-            &bucket,
-            store.bucket_incarnation_id(&bucket).await.expect("bucket incarnation"),
-            "unadmitted.txt",
-            head,
-        );
+        let mut write_request = request(&bucket, "unadmitted.txt", head);
         write_request.tags = Some(HashMap::from([("replicate".to_string(), "no".to_string())]));
         OnDemandMigrationWriteBack::new()
             .put_object(&write_request, body_stream(&body))
@@ -1218,7 +1059,7 @@ mod tests {
 
     #[test]
     fn provenance_and_tags_are_stable() {
-        let mut request = request("b", Uuid::nil(), "k", source_head(b"x"));
+        let mut request = request("b", "k", source_head(b"x"));
         let metadata = provenance_metadata(&request);
         assert_eq!(metadata.len(), 10, "five keys under two prefixes");
         assert_provenance(&metadata, &request.head);
@@ -1239,7 +1080,7 @@ mod tests {
     #[tokio::test]
     async fn write_back_context_applies_the_etag_and_event_policy() {
         let body = b"context".to_vec();
-        let mut request = request("no-such-bucket", Uuid::nil(), "k", source_head(&body));
+        let mut request = request("no-such-bucket", "k", source_head(&body));
         let ctx = write_back_context(&request, true).await;
         assert_eq!(ctx.expected_md5_hex, Some(md5_hex(&body)));
         assert_eq!(ctx.preserve_etag, Some(md5_hex(&body)));

rustfs/src/app/object/put.rs

@@ -953,7 +953,6 @@ pub(super) enum PutObjectOrigin<'a> {
         principal_id: &'static str,
         emit_events: bool,
         preserve_delete_marker: bool,
-        expected_bucket_incarnation_id: Option<Uuid>,
     },
 }
 
@@ -968,13 +967,7 @@ impl PutObjectOrigin<'_> {
     fn apply_bucket_generation_guard(&self, bucket: &str, opts: &mut ObjectOptions) -> S3Result<()> {
         match self {
             Self::S3 { req, .. } => apply_bucket_generation_guard(req, bucket, opts),
-            Self::Internal {
-                expected_bucket_incarnation_id,
-                ..
-            } => {
-                opts.expected_bucket_incarnation_id = *expected_bucket_incarnation_id;
-                Ok(())
-            }
+            Self::Internal { .. } => Ok(()),
         }
     }
 

rustfs/src/app/object/shared.rs

@@ -15,7 +15,9 @@
 //! Cross-cutting helpers shared by the object use-case modules.
 
 use super::*;
-use crate::on_demand_migration::{OdmStateError, PolicyConfig, SourceErrorPolicy, SourceHead};
+use crate::app::storage_api::object_usecase::bucket::on_demand_migration::{
+    OdmStateError, PolicyConfig, SourceErrorPolicy, SourceHead,
+};
 
 pub(super) const RUSTFS_EXPECTED_CURRENT_VERSION_ID: &str = "x-rustfs-expected-current-version-id";
 
@@ -990,7 +992,7 @@ pub(crate) fn odm_source_error_response(policy: &PolicyConfig, class: &'static s
 /// Metrics/message label for a bucket whose source client could not be built.
 pub(crate) fn odm_state_error_class(error: &OdmStateError) -> &'static str {
     match error {
-        OdmStateError::AnonymousUnsupported | OdmStateError::BackendNotCompiled(_) => "unsupported",
+        OdmStateError::AnonymousUnsupported => "unsupported",
         OdmStateError::ClientBuild(_) => "client_build",
     }
 }
@@ -2033,7 +2035,6 @@ mod on_demand_migration_tests {
     #[test]
     fn odm_state_error_class_is_stable() {
         assert_eq!(odm_state_error_class(&OdmStateError::AnonymousUnsupported), "unsupported");
-        assert_eq!(odm_state_error_class(&OdmStateError::BackendNotCompiled("gcs_native")), "unsupported");
         assert_eq!(odm_state_error_class(&OdmStateError::ClientBuild("tls".to_string())), "client_build");
     }
 

rustfs/src/app/storage_api.rs

@@ -27,20 +27,15 @@ pub(crate) fn EndpointServerPools(
 /// S3 wire types for app-layer modules, funneled here so new files stay off
 /// the direct s3s surface (s3s footprint ratchet, `scripts/check_s3s_footprint.sh`).
 pub(crate) mod s3 {
-    #[cfg(test)]
-    pub(crate) use s3s::S3Response;
-    #[cfg(test)]
-    pub(crate) use s3s::dto::ListObjectsInput;
     #[cfg(test)]
     pub(crate) use s3s::dto::{
-        BucketVersioningStatus, DeleteMarkerReplication, DeleteMarkerReplicationStatus, Destination, GetObjectInput,
-        HeadObjectInput, ListObjectsV2Input, ListObjectsV2Output, ReplicationConfiguration, ReplicationRule,
-        ReplicationRuleFilter, ReplicationRuleStatus, ServerSideEncryptionByDefault, ServerSideEncryptionConfiguration,
-        ServerSideEncryptionRule, Tag, VersioningConfiguration,
+        BucketVersioningStatus, DeleteMarkerReplication, DeleteMarkerReplicationStatus, Destination, ListObjectsV2Input,
+        ListObjectsV2Output, ReplicationConfiguration, ReplicationRule, ReplicationRuleFilter, ReplicationRuleStatus,
+        ServerSideEncryptionByDefault, ServerSideEncryptionConfiguration, ServerSideEncryptionRule, Tag, VersioningConfiguration,
     };
+    pub(crate) use s3s::{S3Error, S3ErrorCode, S3Result};
     #[cfg(test)]
-    pub(crate) use s3s::xml::{Serialize as XmlSerialize, Serializer as XmlSerializer};
-    pub(crate) use s3s::{S3Error, S3ErrorCode, S3Request, S3Result};
+    pub(crate) use s3s::{S3Request, S3Response};
 }
 
 pub(crate) mod admin {
@@ -267,9 +262,8 @@ pub(crate) mod access {
     pub(crate) use crate::storage::storage_api::access_consumer::{
         PostObjectRequestMarker, apply_bucket_generation_guard, apply_copy_source_bucket_generation_guard, authorize_request,
         bucket_config_mutation_incarnation, has_bypass_governance_header, load_bucket_generation_from_store,
-        log_list_buckets_iam_implicit_deny, odm_read_generation, prepare_list_buckets_iam_authorization,
-        prepare_odm_read_generation, recursive_force_delete_is_authorized, replication_request_authorized, req_info_mut,
-        req_info_ref,
+        log_list_buckets_iam_implicit_deny, prepare_list_buckets_iam_authorization, recursive_force_delete_is_authorized,
+        replication_request_authorized, req_info_mut, req_info_ref,
     };
 }
 
@@ -634,6 +628,26 @@ pub(crate) mod bucket {
         }
     }
 
+    pub(crate) mod on_demand_migration {
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::source_client::{
+            SourceClient, SourceError, SourceGet, SourceHead, SourceListRequest, SourceObject, SourcePage,
+        };
+        #[cfg(test)]
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::{
+            BREAKER_FAILURE_THRESHOLD, BreakerState, FilterConfig, MAX_LIST_NO_PROGRESS_PAGES, OnDemandMigrationConfig,
+            PathStyle, Provider, SourceConfig, SourceCredentials, TlsConfig,
+        };
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::{
+            BucketOdmState, HeadPolicy, OdmLookup, OdmOp, OdmOutcome, OdmStateError, OnDemandMigrationSys, PolicyConfig,
+            PullError, PullLeader, PullOutcome, PullReason, PullSlot, RangeGetPolicy, SourceBody, SourceErrorPolicy,
+            commit_inline, idle_guarded_body,
+        };
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::{
+            ListEntryKey, ListPageError, ListThroughCursor, ListThroughMerger, ListThroughToken, ListThroughTokenError,
+            MergeSide, SOURCE_LIST_MAX_RATE_WAIT, SourceListPlan, decode_continuation_token, source_list_plan,
+        };
+    }
+
     pub(crate) mod policy_sys {
         pub(crate) type PolicySys = crate::storage::storage_api::ecstore_bucket::policy_sys::PolicySys;
     }
@@ -1167,6 +1181,19 @@ pub(crate) mod bucket_usecase {
 pub(crate) mod object_usecase {
     pub(crate) use super::storage_contracts::BUCKET_LIFECYCLE_LOCK_OBJECT;
 
+    pub(crate) mod on_demand_migration {
+        #[cfg(test)]
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::PullFailureReason;
+        #[cfg(test)]
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::source_client::SourceSse;
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::source_client::{
+            SourceHead, is_multipart_etag,
+        };
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::{
+            LocalObject, OdmWriteBack, WriteBackBody, WriteBackError, WriteBackOutcome, WriteBackPart, WriteBackRequest,
+        };
+    }
+
     pub(crate) mod object_cache {
         #[cfg(test)]
         pub(crate) use crate::storage::storage_api::ecstore_object::GetObjectBodySource;

rustfs/src/lib.rs

@@ -93,7 +93,6 @@ pub(crate) mod kms_rekey;
 pub mod license;
 pub mod memory_observability;
 pub mod module_switches;
-pub mod on_demand_migration;
 pub mod profiling;
 #[cfg(any(feature = "ftps", feature = "webdav", feature = "sftp"))]
 pub mod protocols;

rustfs/src/on_demand_migration/metrics.rs

@@ -1,147 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! Projection of application runtime state onto observability-owned DTOs.
-
-use crate::on_demand_migration::backfill::{
-    BackfillCheckpoint as SourceBackfillCheckpoint, global_backfill_runner as source_global_backfill_runner,
-};
-use crate::on_demand_migration::{
-    BreakerState as SourceOdmBreakerState, OdmBucketSnapshot as SourceOdmBucketSnapshot,
-    OnDemandMigrationSys as SourceOnDemandMigrationSys,
-};
-use rustfs_obs::metrics::{
-    OdmBackfillBucketStats, OnDemandMigrationBreakerState, OnDemandMigrationBucketStats,
-    register_on_demand_migration_metrics_source,
-};
-
-pub(super) fn register() {
-    register_on_demand_migration_metrics_source(snapshot, backfill_snapshot);
-}
-
-fn on_demand_migration_stats_from_snapshot(snapshot: SourceOdmBucketSnapshot) -> OnDemandMigrationBucketStats {
-    let stats = snapshot.stats;
-    OnDemandMigrationBucketStats {
-        bucket: snapshot.bucket,
-        requests_total: stats.requests_total,
-        pulled_bytes_total: stats.pulled_bytes_total,
-        pulled_objects_total: stats.pulled_objects_total,
-        pull_failures_total: stats.pull_failures_total,
-        inflight_pulls: stats.inflight_pulls,
-        queue_depth: stats.queue_depth,
-        source_latency_buckets: stats
-            .source_latency
-            .buckets
-            .into_iter()
-            .map(|bucket| (bucket.le_ms, bucket.count))
-            .collect(),
-        source_latency_count: stats.source_latency.count,
-        source_latency_sum_ms: stats.source_latency.sum_ms,
-        breaker_state: match stats.breaker_state {
-            SourceOdmBreakerState::Closed => OnDemandMigrationBreakerState::Closed,
-            SourceOdmBreakerState::HalfOpen => OnDemandMigrationBreakerState::HalfOpen,
-            SourceOdmBreakerState::Open => OnDemandMigrationBreakerState::Open,
-        },
-    }
-}
-
-/// Every bucket with live on-demand migration state on this node, sorted by
-/// name. Empty while the module switch is off.
-fn snapshot() -> Vec<OnDemandMigrationBucketStats> {
-    SourceOnDemandMigrationSys::get()
-        .snapshot()
-        .into_iter()
-        .map(on_demand_migration_stats_from_snapshot)
-        .collect()
-}
-
-fn on_demand_migration_backfill_stats_from_checkpoint(
-    bucket: String,
-    checkpoint: SourceBackfillCheckpoint,
-) -> OdmBackfillBucketStats {
-    OdmBackfillBucketStats {
-        bucket,
-        state: checkpoint.state.as_str().to_string(),
-        listed: checkpoint.listed,
-        enqueued: checkpoint.enqueued,
-        pulled: checkpoint.pulled,
-        skipped_existing: checkpoint.skipped_existing,
-        failed: checkpoint.failed,
-        bytes: checkpoint.bytes,
-    }
-}
-
-/// Backfill jobs running on this node, sorted by bucket. Empty until the
-/// runner is installed, and empty again once a job finishes: the series are
-/// per-node job progress, not a cluster-wide history.
-fn backfill_snapshot() -> Vec<OdmBackfillBucketStats> {
-    source_global_backfill_runner()
-        .map(|runner| {
-            runner
-                .local_job_snapshots()
-                .into_iter()
-                .map(|(bucket, checkpoint)| on_demand_migration_backfill_stats_from_checkpoint(bucket, checkpoint))
-                .collect()
-        })
-        .unwrap_or_default()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn on_demand_migration_snapshot_projects_counters_and_breaker_state() {
-        // Pin the runtime wire snapshot and its observability projection together.
-        let snapshot: SourceOdmBucketSnapshot = serde_json::from_value(serde_json::json!({
-            "bucket": "photos",
-            "provider": "minio",
-            "endpoint_host": "source.example.com",
-            "applied_at": "2026-09-02T10:00:00Z",
-            "client_error": null,
-            "negative_cache_entries": 0,
-            "inflight_keys": 1,
-            "max_concurrent_pulls": 8,
-            "stats": {
-                "requests_total": {"get": {"source_hit": 2}},
-                "pulled_bytes_total": 4096,
-                "pulled_objects_total": {"inline": 1},
-                "pull_failures_total": {"source_timeout": 1},
-                "inflight_pulls": 1,
-                "queue_depth": 2,
-                "source_latency": {
-                    "buckets": [{"le_ms": 5, "count": 1}, {"le_ms": 10, "count": 2}],
-                    "count": 3,
-                    "sum_ms": 90753
-                },
-                "last_source_error": {"class": "server_error", "at": "2026-09-02T10:00:00Z"},
-                "breaker_state": "open"
-            }
-        }))
-        .expect("runtime snapshot decodes");
-
-        let stats = on_demand_migration_stats_from_snapshot(snapshot);
-
-        assert_eq!(stats.bucket, "photos");
-        assert_eq!(stats.requests_total["get"]["source_hit"], 2);
-        assert_eq!(stats.pulled_bytes_total, 4096);
-        assert_eq!(stats.pulled_objects_total["inline"], 1);
-        assert_eq!(stats.pull_failures_total["source_timeout"], 1);
-        assert_eq!(stats.inflight_pulls, 1);
-        assert_eq!(stats.queue_depth, 2);
-        assert_eq!(stats.source_latency_buckets, vec![(5, 1), (10, 2)]);
-        assert_eq!(stats.source_latency_count, 3);
-        assert_eq!(stats.source_latency_sum_ms, 90_753);
-        assert_eq!(stats.breaker_state, OnDemandMigrationBreakerState::Open);
-    }
-}

rustfs/src/on_demand_migration/storage_api.rs

@@ -1,28 +0,0 @@
-// Copyright 2024 RustFS Team
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-//! Storage capabilities used by on-demand migration orchestration.
-
-#[cfg(test)]
-pub(super) use crate::storage_api::on_demand_migration::test_support;
-pub(super) use crate::storage_api::on_demand_migration::{
-    BUCKET_CONFIG_PUBLISH_HOOK, BUCKET_META_PREFIX, BUCKET_ON_DEMAND_MIGRATION_CONFIG, ECStore, HTTPPreconditions, HTTPRangeSpec,
-    NamespaceLocking, ObjectOperations, ObjectOptions, RUSTFS_META_BUCKET, StorageError, WriteCompletion,
-    get_lock_acquire_timeout, get_on_demand_migration_config, get_on_demand_migration_config_in, read_config_with_metadata,
-    remote_s3_client, save_config_with_opts,
-};
-
-pub(super) async fn local_node_name() -> String {
-    rustfs_common::get_global_local_node_name().await
-}

rustfs/src/startup_background.rs

@@ -17,11 +17,10 @@ use crate::module_switches::{
     bitrot_selftest_enabled_from_env, bitrot_selftest_strict_from_env, heal_enabled_from_env,
     is_on_demand_migration_module_enabled, scanner_enabled_from_env,
 };
-use crate::on_demand_migration::OnDemandMigrationSys;
-use crate::on_demand_migration::backfill::{
-    BackfillRunner, SysBackfillContexts, install_global_backfill_runner, spawn_backfill_recovery_loop,
+use crate::storage_api::startup::background::{
+    BackfillRunner, ECStore, OnDemandMigrationSys, SysBackfillContexts, install_global_backfill_runner,
+    set_workload_admission_snapshot_provider, spawn_backfill_recovery_loop,
 };
-use crate::storage_api::startup::background::{ECStore, set_workload_admission_snapshot_provider};
 use crate::workload_admission::RustFsWorkloadAdmissionSnapshotProvider;
 use rustfs_concurrency::WorkloadAdmissionSnapshotProvider;
 use rustfs_heal::{

rustfs/src/startup_bucket_metadata.rs

@@ -14,11 +14,10 @@
 
 use crate::app::object::OnDemandMigrationWriteBack;
 use crate::module_switches::{on_demand_migration_enabled_from_env, set_on_demand_migration_module_enabled};
-use crate::on_demand_migration::OnDemandMigrationSys;
 use crate::storage_api::startup::bucket_metadata::contract::bucket::{BucketOperations, BucketOptions};
 use crate::storage_api::startup::bucket_metadata::{
-    ECStore, Error as StorageError, Result as StorageResult, get_global_replication_pool, init_bucket_metadata_sys,
-    reconcile_bucket_resync_target_intents, try_migrate_bucket_metadata, try_migrate_iam_config,
+    ECStore, Error as StorageError, OnDemandMigrationSys, Result as StorageResult, get_global_replication_pool,
+    init_bucket_metadata_sys, reconcile_bucket_resync_target_intents, try_migrate_bucket_metadata, try_migrate_iam_config,
 };
 use std::{
     io::{Error as IoError, Result as IoResult},
@@ -99,7 +98,6 @@ pub(crate) async fn init_bucket_metadata_runtime(store: Arc<ECStore>, ctx: Cance
 /// `OnDemandMigrationSys` with a usable write-back (rustfs/backlog#2152).
 /// Idempotent across embedded and server startups.
 fn init_on_demand_migration_runtime() {
-    crate::on_demand_migration::register_metrics();
     let enabled = on_demand_migration_enabled_from_env();
     set_on_demand_migration_module_enabled(enabled);
     let sys = OnDemandMigrationSys::get();

rustfs/src/storage/access.rs

@@ -288,68 +288,6 @@ async fn load_bucket_generation<T>(fs: &FS, req: &S3Request<T>, bucket: &str) ->
     load_bucket_generation_from_store(store.as_ref(), req, bucket).await
 }
 
-/// A read may consult only the source admitted before its authorization.
-/// Capture failures are deferred until a local miss actually needs that source.
-#[derive(Clone, Debug)]
-enum OdmReadGenerationGuard {
-    Unavailable,
-    Ready(BucketGenerationGuard),
-    Failed { code: S3ErrorCode, message: String },
-}
-
-impl OdmReadGenerationGuard {
-    fn from_result(result: S3Result<BucketGenerationGuard>) -> Self {
-        match result {
-            Ok(guard) => Self::Ready(guard),
-            Err(err) => Self::Failed {
-                code: err.code().clone(),
-                message: err.message().unwrap_or_else(|| err.code().as_str()).to_string(),
-            },
-        }
-    }
-}
-
-fn odm_read_source_configured(bucket: &str) -> bool {
-    let sys = crate::on_demand_migration::OnDemandMigrationSys::get();
-    sys.is_module_enabled() && sys.state(bucket).is_some()
-}
-
-async fn capture_odm_read_generation<T>(fs: &FS, req: &S3Request<T>, bucket: &str) -> OdmReadGenerationGuard {
-    if !odm_read_source_configured(bucket) {
-        return OdmReadGenerationGuard::Unavailable;
-    }
-    OdmReadGenerationGuard::from_result(load_bucket_generation(fs, req, bucket).await)
-}
-
-/// Direct usecase callers have no access middleware; capture at their entry.
-/// A server request without the access marker must never bind to a later source.
-pub(crate) async fn prepare_odm_read_generation<T>(
-    store: &crate::storage::storage_api::ECStore,
-    req: &mut S3Request<T>,
-    bucket: &str,
-) {
-    if req.extensions.get::<OdmReadGenerationGuard>().is_some() {
-        return;
-    }
-    let guard = if req.extensions.get::<std::sync::Arc<ServerContextSlot>>().is_some() || !odm_read_source_configured(bucket) {
-        OdmReadGenerationGuard::Unavailable
-    } else {
-        OdmReadGenerationGuard::from_result(load_bucket_generation_from_store(store, req, bucket).await)
-    };
-    req.extensions.insert(guard);
-}
-
-pub(crate) fn odm_read_generation<T>(req: &S3Request<T>, bucket: &str) -> S3Result<Option<uuid::Uuid>> {
-    match req.extensions.get::<OdmReadGenerationGuard>() {
-        Some(OdmReadGenerationGuard::Ready(guard)) if guard.bucket == bucket => Ok(Some(guard.incarnation_id)),
-        Some(OdmReadGenerationGuard::Ready(_)) => {
-            Err(s3_error!(InternalError, "source generation guard does not match request bucket"))
-        }
-        Some(OdmReadGenerationGuard::Failed { code, message }) => Err(S3Error::with_message(code.clone(), message.clone())),
-        Some(OdmReadGenerationGuard::Unavailable) | None => Ok(None),
-    }
-}
-
 async fn load_copy_source_bucket_generation(fs: &FS, bucket: &str) -> S3Result<CopySourceBucketGenerationGuard> {
     let store = fs
         .server_ctx()
@@ -2427,8 +2365,6 @@ impl S3Access for FS {
     ///
     /// This method returns `Ok(())` by default.
     async fn get_object(&self, req: &mut S3Request<GetObjectInput>) -> S3Result<()> {
-        let bucket = req.input.bucket.clone();
-        let source_generation = capture_odm_read_generation(self, req, &bucket).await;
         let req_info = ext_req_info_mut(&mut req.extensions)?;
         req_info.bucket = Some(req.input.bucket.clone());
         req_info.object = Some(req.input.key.clone());
@@ -2436,9 +2372,7 @@ impl S3Access for FS {
 
         // GHSA-3ppv: a versioned read (?versionId=...) must authorize against
         // s3:GetObjectVersion, not s3:GetObject.
-        authorize_request(req, versioned_read_action(req.input.version_id.as_deref())).await?;
-        req.extensions.insert(source_generation);
-        Ok(())
+        authorize_request(req, versioned_read_action(req.input.version_id.as_deref())).await
     }
 
     /// Checks whether the GetObjectAcl request has accesses to the resources.
@@ -2550,8 +2484,6 @@ impl S3Access for FS {
     ///
     /// This method returns `Ok(())` by default.
     async fn head_object(&self, req: &mut S3Request<HeadObjectInput>) -> S3Result<()> {
-        let bucket = req.input.bucket.clone();
-        let source_generation = capture_odm_read_generation(self, req, &bucket).await;
         let req_info = ext_req_info_mut(&mut req.extensions)?;
         req_info.bucket = Some(req.input.bucket.clone());
         req_info.object = Some(req.input.key.clone());
@@ -2564,13 +2496,10 @@ impl S3Access for FS {
         if get_header(&req.headers, SUFFIX_SOURCE_REPLICATION_CHECK).as_deref() == Some("true") {
             authorize_request(req, Action::S3Action(S3Action::ReplicateObjectAction)).await?;
             req_info_mut(req)?.replication_request_authorized = true;
-            req.extensions.insert(source_generation);
             return Ok(());
         }
 
-        authorize_request(req, Action::S3Action(S3Action::GetObjectAction)).await?;
-        req.extensions.insert(source_generation);
-        Ok(())
+        authorize_request(req, Action::S3Action(S3Action::GetObjectAction)).await
     }
 
     /// Checks whether the ListBucketAnalyticsConfigurations request has accesses to the resources.
@@ -2659,14 +2588,10 @@ impl S3Access for FS {
     ///
     /// This method returns `Ok(())` by default.
     async fn list_objects_v2(&self, req: &mut S3Request<ListObjectsV2Input>) -> S3Result<()> {
-        let bucket = req.input.bucket.clone();
-        let source_generation = capture_odm_read_generation(self, req, &bucket).await;
         let req_info = ext_req_info_mut(&mut req.extensions)?;
         req_info.bucket = Some(req.input.bucket.clone());
 
-        authorize_request(req, Action::S3Action(S3Action::ListBucketAction)).await?;
-        req.extensions.insert(source_generation);
-        Ok(())
+        authorize_request(req, Action::S3Action(S3Action::ListBucketAction)).await
     }
 
     /// Checks whether the ListParts request has accesses to the resources.
@@ -3933,285 +3858,6 @@ mod tests {
         assert_eq!(req_info.object.as_deref(), Some("test-key"));
     }
 
-    #[test]
-    #[serial]
-    fn odm_read_capture_preserves_access_and_parameter_error_order() {
-        crate::app::gating_test_env::run_large_stack_test("odm-access-order", || async {
-            let context = crate::app::gating_test_env::shared_gating_ambient().await;
-            let server_ctx = ServerContextSlot::new();
-            assert!(server_ctx.install(Arc::clone(&context)));
-            let fs = FS::with_server_ctx(server_ctx);
-            let sys = crate::on_demand_migration::OnDemandMigrationSys::get();
-            let enabled_before = sys.is_module_enabled();
-            let bucket = format!("odm-access-missing-{}", uuid::Uuid::new_v4());
-            for enabled in [false, true] {
-                sys.set_module_enabled(enabled);
-                let mut get = build_request(
-                    GetObjectInput {
-                        bucket: bucket.clone(),
-                        key: "key".into(),
-                        part_number: Some(0),
-                        ..Default::default()
-                    },
-                    Method::GET,
-                );
-                get.extensions.insert(ReqInfo {
-                    cred: Some(rustfs_credentials::Credentials::default()),
-                    is_owner: true,
-                    ..Default::default()
-                });
-                get.extensions.insert(fs.server_ctx().clone());
-                let mut head = get.clone().map_input(|_| HeadObjectInput {
-                    bucket: bucket.clone(),
-                    key: "key".into(),
-                    part_number: Some(1),
-                    range: Some(s3s::dto::Range::Int { first: 0, last: Some(1) }),
-                    ..Default::default()
-                });
-                head.method = Method::HEAD;
-                let mut list = get.clone().map_input(|_| ListObjectsV2Input {
-                    bucket: bucket.clone(),
-                    max_keys: Some(-1),
-                    ..Default::default()
-                });
-                fs.get_object(&mut get)
-                    .await
-                    .expect("ordinary GET access must not require bucket identity");
-                fs.head_object(&mut head)
-                    .await
-                    .expect("ordinary HEAD access must not require bucket identity");
-                fs.list_objects_v2(&mut list)
-                    .await
-                    .expect("ordinary LIST access must not require bucket identity");
-                assert!(matches!(
-                    get.extensions.get::<super::OdmReadGenerationGuard>(),
-                    Some(super::OdmReadGenerationGuard::Unavailable)
-                ));
-                assert!(matches!(
-                    head.extensions.get::<super::OdmReadGenerationGuard>(),
-                    Some(super::OdmReadGenerationGuard::Unavailable)
-                ));
-                assert!(matches!(
-                    list.extensions.get::<super::OdmReadGenerationGuard>(),
-                    Some(super::OdmReadGenerationGuard::Unavailable)
-                ));
-                let usecase = crate::app::object_usecase::DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
-                assert_eq!(
-                    usecase.execute_get_object(get).await.expect_err("bad GET part number").code(),
-                    &S3ErrorCode::InvalidArgument
-                );
-                assert_eq!(
-                    usecase
-                        .execute_head_object(head)
-                        .await
-                        .expect_err("range and part number conflict")
-                        .code(),
-                    &S3ErrorCode::InvalidArgument
-                );
-                assert_eq!(
-                    crate::app::bucket_usecase::DefaultBucketUsecase::with_context(Some(Arc::clone(&context)))
-                        .execute_list_objects_v2(list)
-                        .await
-                        .expect_err("negative max keys")
-                        .code(),
-                    &S3ErrorCode::InvalidArgument
-                );
-            }
-            sys.set_module_enabled(enabled_before);
-        });
-    }
-
-    #[test]
-    #[serial]
-    fn odm_read_capture_failure_is_deferred_until_source_miss() {
-        crate::app::gating_test_env::run_large_stack_test("odm-access-failure", || async {
-            let context = crate::app::gating_test_env::shared_gating_ambient().await;
-            let store = context.object_store();
-            let server_ctx = ServerContextSlot::new();
-            assert!(server_ctx.install(Arc::clone(&context)));
-            let fs = FS::with_server_ctx(server_ctx);
-            let sys = crate::on_demand_migration::OnDemandMigrationSys::get();
-            let enabled_before = sys.is_module_enabled();
-            sys.set_module_enabled(true);
-            let bucket = format!("odm-capture-failure-{}", uuid::Uuid::new_v4());
-            let mut config: crate::on_demand_migration::OnDemandMigrationConfig = serde_json::from_str(r#"{"source":{"provider":"minio","endpoint":"https://source.example.com","region":"us-east-1","bucket":"source","credentials":{"access_key":"test","secret_key":"test"}}}"#).expect("source config");
-            config.policy.list_through = true;
-            sys.apply_for_incarnation(&bucket, uuid::Uuid::new_v4(), Some(&config)).await;
-            let mut get = build_request(
-                GetObjectInput {
-                    bucket: bucket.clone(),
-                    key: "local".into(),
-                    ..Default::default()
-                },
-                Method::GET,
-            );
-            get.extensions.insert(ReqInfo {
-                cred: Some(rustfs_credentials::Credentials::default()),
-                is_owner: true,
-                ..Default::default()
-            });
-            get.extensions.insert(fs.server_ctx().clone());
-            let mut head = get.clone().map_input(|_| HeadObjectInput {
-                bucket: bucket.clone(),
-                key: "local".into(),
-                ..Default::default()
-            });
-            head.method = Method::HEAD;
-            let mut list = get.clone().map_input(|_| ListObjectsV2Input {
-                bucket: bucket.clone(),
-                ..Default::default()
-            });
-            fs.list_objects_v2(&mut list)
-                .await
-                .expect("capture failure must not preempt LIST authorization");
-            fs.get_object(&mut get)
-                .await
-                .expect("capture failure must not preempt GET authorization");
-            fs.head_object(&mut head)
-                .await
-                .expect("capture failure must not preempt HEAD authorization");
-            assert!(matches!(
-                get.extensions.get::<super::OdmReadGenerationGuard>(),
-                Some(super::OdmReadGenerationGuard::Failed { .. })
-            ));
-            assert!(matches!(
-                head.extensions.get::<super::OdmReadGenerationGuard>(),
-                Some(super::OdmReadGenerationGuard::Failed { .. })
-            ));
-            store
-                .make_bucket(
-                    &bucket,
-                    &MakeBucketOptions {
-                        versioning_enabled: true,
-                        ..Default::default()
-                    },
-                )
-                .await
-                .expect("create bucket after capture");
-            store
-                .put_object(
-                    &bucket,
-                    "local",
-                    &mut crate::storage::PutObjReader::from_vec(b"local".to_vec()),
-                    &crate::storage::ObjectOptions::default(),
-                )
-                .await
-                .expect("create local hit");
-            // Publishing a usable source later must not repair a failed capture.
-            let incarnation = store.bucket_incarnation_id(&bucket).await.expect("created identity");
-            sys.apply_for_incarnation(&bucket, incarnation, Some(&config)).await;
-            let usecase = crate::app::object_usecase::DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
-            usecase
-                .execute_get_object(get.clone())
-                .await
-                .expect("a local GET hit ignores source capture failure");
-            usecase
-                .execute_head_object(head.clone())
-                .await
-                .expect("a local HEAD hit ignores source capture failure");
-            get.input.key = "missing".into();
-            head.input.key = "missing".into();
-            assert_eq!(
-                usecase
-                    .execute_get_object(get.clone())
-                    .await
-                    .expect_err("failed capture cannot rebind on GET miss")
-                    .code(),
-                &S3ErrorCode::NoSuchBucket
-            );
-            assert_eq!(
-                usecase
-                    .execute_head_object(head.clone())
-                    .await
-                    .expect_err("failed capture cannot rebind on HEAD miss")
-                    .code(),
-                &S3ErrorCode::NoSuchBucket
-            );
-            assert_eq!(
-                crate::app::bucket_usecase::DefaultBucketUsecase::with_context(Some(Arc::clone(&context)))
-                    .execute_list_objects_v2(list.clone())
-                    .await
-                    .expect_err("failed capture cannot rebind on LIST")
-                    .code(),
-                &S3ErrorCode::NoSuchBucket
-            );
-            config.filter.prefix = Some("remote/".into());
-            sys.apply_for_incarnation(&bucket, incarnation, Some(&config)).await;
-            assert_eq!(
-                usecase
-                    .execute_get_object(get.clone())
-                    .await
-                    .expect_err("filtered GET remains local")
-                    .code(),
-                &S3ErrorCode::NoSuchKey
-            );
-            assert_eq!(
-                usecase
-                    .execute_head_object(head.clone())
-                    .await
-                    .expect_err("filtered HEAD remains local")
-                    .code(),
-                &S3ErrorCode::NoSuchKey
-            );
-            list.input.prefix = Some("local/".into());
-            let listing = crate::app::bucket_usecase::DefaultBucketUsecase::with_context(Some(Arc::clone(&context)))
-                .execute_list_objects_v2(list.clone())
-                .await
-                .expect("disjoint prefix needs no source identity");
-            assert_eq!(listing.output.key_count, Some(0));
-            list.input.prefix = Some("remote/".into());
-            list.input.max_keys = Some(0);
-            let listing = crate::app::bucket_usecase::DefaultBucketUsecase::with_context(Some(Arc::clone(&context)))
-                .execute_list_objects_v2(list)
-                .await
-                .expect("an empty page needs no source identity");
-            assert_eq!(listing.output.key_count, Some(0));
-
-            config.filter.prefix = None;
-            config.policy.head = crate::on_demand_migration::HeadPolicy::LocalOnly;
-            sys.apply_for_incarnation(&bucket, incarnation, Some(&config)).await;
-            assert_eq!(
-                usecase
-                    .execute_head_object(head.clone())
-                    .await
-                    .expect_err("local-only HEAD needs no source identity")
-                    .code(),
-                &S3ErrorCode::NoSuchKey
-            );
-            config.policy.head = crate::on_demand_migration::HeadPolicy::Proxy;
-            sys.apply_for_incarnation(&bucket, incarnation, Some(&config)).await;
-            store
-                .delete_object(
-                    &bucket,
-                    "missing",
-                    crate::storage::ObjectOptions {
-                        versioned: true,
-                        ..Default::default()
-                    },
-                )
-                .await
-                .expect("create local delete marker");
-            assert_eq!(
-                usecase
-                    .execute_get_object(get)
-                    .await
-                    .expect_err("GET respects the delete marker before capture failure")
-                    .code(),
-                &S3ErrorCode::NoSuchKey
-            );
-            assert_eq!(
-                usecase
-                    .execute_head_object(head)
-                    .await
-                    .expect_err("HEAD respects the delete marker before capture failure")
-                    .code(),
-                &S3ErrorCode::NoSuchKey
-            );
-            sys.remove(&bucket);
-            sys.set_module_enabled(enabled_before);
-        });
-    }
-
     #[tokio::test]
     #[serial]
     async fn put_object_access_captures_authorized_bucket_incarnation() {

rustfs/src/storage/storage_api.rs

@@ -119,9 +119,8 @@ pub(crate) mod access_consumer {
     pub(crate) use super::super::access::{
         PostObjectRequestMarker, ReqInfo, apply_bucket_generation_guard, apply_copy_source_bucket_generation_guard,
         authorize_internal_object_request, authorize_request, bucket_config_mutation_incarnation, has_bypass_governance_header,
-        load_bucket_generation_from_store, log_list_buckets_iam_implicit_deny, odm_read_generation,
-        prepare_list_buckets_iam_authorization, prepare_odm_read_generation, recursive_force_delete_is_authorized,
-        replication_request_authorized, req_info_mut, req_info_ref,
+        load_bucket_generation_from_store, log_list_buckets_iam_implicit_deny, prepare_list_buckets_iam_authorization,
+        recursive_force_delete_is_authorized, replication_request_authorized, req_info_mut, req_info_ref,
     };
 }
 
@@ -408,8 +407,8 @@ pub(crate) mod ecstore_bucket {
     #[cfg(test)]
     pub(crate) use rustfs_ecstore::api::bucket::lifecycle::tier_delete_journal::test_util::install_all_v6_fleet_capability_proof;
     pub(crate) use rustfs_ecstore::api::bucket::{
-        bandwidth, bucket_target_sys, durability, lifecycle, metadata, metadata_sys, migration, object_lock, policy_sys,
-        remote_s3_client, replication, tagging, target, utils,
+        bandwidth, bucket_target_sys, durability, lifecycle, metadata, metadata_sys, migration, object_lock, on_demand_migration,
+        policy_sys, remote_s3_client, replication, tagging, target, utils,
     };
     pub(crate) use rustfs_ecstore::api::bucket::{quota, versioning, versioning_sys};
 }
@@ -467,10 +466,10 @@ pub(crate) mod ecstore_data_usage {
 #[allow(unused_imports)]
 pub(crate) mod ecstore_disk {
     pub(crate) use rustfs_ecstore::api::disk::{
-        BUCKET_META_PREFIX, BatchReadVersionReq, BatchReadVersionResp, CheckPartsResp, DeleteOptions, DiskAPI, DiskInfo,
-        DiskInfoOptions, DiskStore, FileInfoVersions, FileReader, FileWriter, OldCurrentSize, PartTransactionAction,
-        RUSTFS_META_BUCKET, ReadMultipleReq, ReadMultipleResp, ReadOptions, RenameDataResp, SnapshotLeaseToken,
-        UpdateMetadataOpts, VolumeInfo, WalkDirOptions, get_object_disk_read_timeout, validate_batch_read_version_item_count,
+        BatchReadVersionReq, BatchReadVersionResp, CheckPartsResp, DeleteOptions, DiskAPI, DiskInfo, DiskInfoOptions, DiskStore,
+        FileInfoVersions, FileReader, FileWriter, OldCurrentSize, PartTransactionAction, RUSTFS_META_BUCKET, ReadMultipleReq,
+        ReadMultipleResp, ReadOptions, RenameDataResp, SnapshotLeaseToken, UpdateMetadataOpts, VolumeInfo, WalkDirOptions,
+        get_object_disk_read_timeout, validate_batch_read_version_item_count,
     };
     pub(crate) use rustfs_ecstore::api::disk::{endpoint, error, error_reduce};
 }
@@ -561,7 +560,7 @@ pub(crate) mod ecstore_object {
     pub(crate) use rustfs_ecstore::api::object::{
         EncryptionResolutionError, EncryptionResolutionErrorKind, GetObjectBodyCacheHook, GetObjectBodyCacheHookLookup,
         ObjectEncryptionResolver, ObjectMutationHook, PrepareSelectObjectSnapshotError, ReadEncryptionMaterial,
-        ReadEncryptionMode, ReadEncryptionRequest, SelectObjectSnapshot, WriteCompletion, get_object_body_cache_plaintext_len,
+        ReadEncryptionMode, ReadEncryptionRequest, SelectObjectSnapshot, get_object_body_cache_plaintext_len,
         lookup_get_object_body_cache_hook, register_get_object_body_cache_hook, register_object_mutation_hook,
         unregister_get_object_body_cache_hook, unregister_object_mutation_hook,
     };

rustfs/src/storage_api.rs

@@ -278,6 +278,10 @@ pub(crate) mod startup {
     }
 
     pub(crate) mod background {
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::OnDemandMigrationSys;
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::backfill::{
+            BackfillRunner, SysBackfillContexts, install_global_backfill_runner, spawn_backfill_recovery_loop,
+        };
         pub(crate) use crate::storage::storage_api::{
             BitrotSelfTestError, ECStore, bitrot_self_test, set_workload_admission_snapshot_provider,
         };
@@ -290,6 +294,7 @@ pub(crate) mod startup {
             }
         }
 
+        pub(crate) use crate::storage::storage_api::ecstore_bucket::on_demand_migration::OnDemandMigrationSys;
         pub(crate) use crate::storage::storage_api::{
             ECStore, Error, Result, get_global_replication_pool, init_bucket_metadata_sys,
             reconcile_bucket_resync_target_intents, try_migrate_bucket_metadata, try_migrate_iam_config,
@@ -410,32 +415,3 @@ pub(crate) mod table {
         get_lock_acquire_timeout, table_catalog_path_hash,
     };
 }
-
-pub(crate) mod on_demand_migration {
-    pub(crate) use crate::storage::storage_api::ECStore;
-    pub(crate) use crate::storage::storage_api::StorageObjectOptions as ObjectOptions;
-    pub(crate) use crate::storage::storage_api::contract::{
-        namespace::NamespaceLocking, object::HTTPPreconditions, object::ObjectOperations, range::HTTPRangeSpec,
-    };
-    pub(crate) use crate::storage::storage_api::ecstore_bucket::metadata::BUCKET_ON_DEMAND_MIGRATION_CONFIG;
-    pub(crate) use crate::storage::storage_api::ecstore_bucket::metadata_sys::{
-        BUCKET_CONFIG_PUBLISH_HOOK, get_on_demand_migration_config, get_on_demand_migration_config_in,
-    };
-    pub(crate) use crate::storage::storage_api::ecstore_bucket::remote_s3_client;
-    pub(crate) use crate::storage::storage_api::ecstore_config::com::{read_config_with_metadata, save_config_with_opts};
-    pub(crate) use crate::storage::storage_api::ecstore_disk::{BUCKET_META_PREFIX, RUSTFS_META_BUCKET};
-    pub(crate) use crate::storage::storage_api::ecstore_error::Error as StorageError;
-    pub(crate) use crate::storage::storage_api::ecstore_object::WriteCompletion;
-    pub(crate) use crate::storage::storage_api::ecstore_set_disk::get_lock_acquire_timeout;
-
-    #[cfg(test)]
-    pub(crate) mod test_support {
-        pub(crate) use crate::storage::storage_api::contract::bucket::{BUCKET_LIFECYCLE_LOCK_OBJECT, BucketOperations};
-        pub(crate) use crate::storage::storage_api::ecstore_bucket::metadata::{
-            BUCKET_ON_DEMAND_MIGRATION_CONFIG, BucketMetadata,
-        };
-        pub(crate) use crate::storage::storage_api::ecstore_bucket::metadata_sys::test_support::isolated_store_over_temp_disks;
-        pub(crate) use crate::storage::storage_api::ecstore_bucket::metadata_sys::{BucketMetadataSys, init_bucket_metadata_sys};
-        pub(crate) use crate::storage::storage_api::ecstore_set_disk::{PutObjectCommitBarrier, PutObjectCommitPause};
-    }
-}

scripts/README.md

@@ -54,6 +54,8 @@ their issue closes.
 | `probe.sh` | dev-tool | Probe-style e2e run | `make probe-e2e` |
 | `run_scanner_validation_harness.sh` | dev-tool | Scanner validation harness | `docs/operations/scanner-benchmark-runbook.md` |
 | `test_scanner_validation_harness.sh` | dev-tool | Self-test for the scanner validation harness | — |
+| `scanner_abba.py` | dev-tool | Scanner/heal ABBA orchestration and evidence gates via `run_scanner_validation_harness.sh --abba` | `docs/operations/scanner-benchmark-runbook.md` |
+| `test_scanner_abba.py` | dev-tool | Synthetic ABBA adapter and failure-path tests | `test_scanner_validation_harness.sh` |
 | `test_build_rustfs_options.sh` | dev-tool | Shell test for rustfs build-option wiring | `make test` (script-tests) |
 | `test_entrypoint_credentials.sh` | dev-tool | Container entrypoint credential-handling test | `make test` (script-tests) |
 | `test_helm_chart_version.sh` | dev-tool | Test for `helm_chart_version.sh` | — |

scripts/check_test_wiring.py

@@ -12,11 +12,15 @@ import sys
 import tempfile
 import tomllib
 import unittest
+import uuid
+import xml.etree.ElementTree as ET
 from datetime import datetime, timezone
 from unittest import mock
 from pathlib import Path
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
+from scanner_abba import MAX_JSON_BYTES, digest, number, read_json, require, sha, write_json
+
 
 ROOT = Path(__file__).resolve().parents[1]
 SCHEDULED_ALERT_WORKFLOWS = tuple(
@@ -873,6 +877,187 @@ def check_core_listing(root: Path, listing: Path) -> list[str]:
         return [f"cannot read core nextest listing: {error}"]
 
 
+def evidence_integer(value: object, name: str, minimum: int, maximum: int) -> int:
+    require(type(value) is int and minimum <= value <= maximum, f"invalid integer {name}")
+    return value
+
+
+def begin_scanner_heal_receipt(root: Path, directory: Path, binary: Path, test_binary: Path) -> None:
+    """Record an existing build; this command never builds or runs a test."""
+    require(not directory.exists(), "scanner/heal run directory must be new")
+    require(not subprocess.check_output(["git", "status", "--porcelain", "--untracked-files=no"], cwd=root, text=True).strip(),
+            "commit tracked source changes before creating evidence")
+    builds = {}
+    for label, path in (("binary", binary), ("test_binary", test_binary)):
+        path = path.resolve(strict=True)
+        require(path.is_file() and os.access(path, os.X_OK), f"missing executable {label}")
+        builds[label] = {"path": str(path), "sha256": digest(path)}
+    revision = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=root, text=True).strip()
+    require(re.fullmatch(r"[0-9a-f]{40}", revision), "invalid source revision")
+    version = subprocess.check_output([builds["binary"]["path"], "--version"], text=True, timeout=30)
+    embedded_revision = re.search(r"^git commit\s*:\s*([0-9a-f]{40})\s*$", version, re.MULTILINE)
+    embedded_status = re.search(r"^git status\s*:\s*(.*)\Z", version, re.MULTILINE | re.DOTALL)
+    require(embedded_revision is not None and embedded_revision[1] == revision, "server binary source revision mismatch")
+    require(embedded_status is not None and not embedded_status[1].strip(), "server binary was built from dirty/unknown source")
+    lock_blob = subprocess.check_output(["git", "hash-object", "Cargo.lock"], cwd=root, text=True).strip()
+    require(re.fullmatch(r"[0-9a-f]{40}", lock_blob), "invalid Cargo.lock identity")
+    features = os.environ.get("RUSTFS_E2E_EXPECTED_FEATURES")
+    require(features is not None, "set RUSTFS_E2E_EXPECTED_FEATURES to the compiled e2e crate feature set")
+    features = ",".join(sorted(set(filter(None, (feature.strip() for feature in features.split(","))))))
+    require(all(re.fullmatch(r"[a-z0-9-]+", feature) for feature in features.split(",") if feature), "invalid expected features")
+    directory.mkdir(parents=True)
+    write_json(directory / "run.json", {"schema": 1, "run_id": uuid.uuid4().hex,
+                                       "source_revision": revision,
+                                       "binary_source_revision": embedded_revision[1],
+                                       "test_build": {"source_revision": revision, "dirty": False,
+                                                      "lock_blob": lock_blob, "features": features},
+                                       "started_at": datetime.now(timezone.utc).timestamp(), **builds})
+
+
+def finish_scanner_heal_receipt(directory: Path, exit_code: int) -> None:
+    require(type(exit_code) is int and 0 <= exit_code <= 255, "invalid test exit code")
+    require(not (directory / "execution.json").exists(), "execution receipt already exists")
+    run = read_json(directory / "run.json")
+    artifacts = {}
+    for name in ("listing.json", "junit.xml", "background-target-restart.json"):
+        path = directory / name
+        if exit_code != 0 and not path.exists():
+            continue
+        require(path.is_file() and 0 < path.stat().st_size <= MAX_JSON_BYTES, f"missing/oversized {name}")
+        require(path.stat().st_mtime >= run["started_at"], f"stale {name}")
+        artifacts[name] = digest(path)
+    write_json(directory / "execution.json", {"run_id": run["run_id"], "exit_code": exit_code,
+                                             "finished_at": datetime.now(timezone.utc).timestamp(),
+                                             "artifacts": artifacts})
+
+
+def check_scanner_heal_evidence(root: Path, directory: Path, case_id: str) -> list[str]:
+    """Validate one actual case, or fail the release while required lanes are pending."""
+    try:
+        registry = read_json(root / ".config/scanner-heal-required-tests.json")
+        evidence_integer(registry.get("schema"), "registry schema", 1, 1)
+        require(registry.get("cases"), "invalid scanner/heal registry")
+        selected = registry["cases"] if case_id == "release" else {case_id: registry["cases"][case_id]}
+        run = read_json(directory / "run.json")
+        execution = read_json(directory / "execution.json")
+        evidence_integer(run.get("schema"), "run schema", 1, 1)
+        require(re.fullmatch(r"[0-9a-f]{32}", run["run_id"]), "invalid run identity")
+        require(re.fullmatch(r"[0-9a-f]{40}", run["source_revision"]), "invalid source revision")
+        require(run.get("binary_source_revision") == run["source_revision"], "server source provenance missing")
+        expected_build = run["test_build"]
+        require(expected_build["source_revision"] == run["source_revision"] and expected_build["dirty"] is False,
+                "test source provenance missing")
+        require(re.fullmatch(r"[0-9a-f]{40}", expected_build["lock_blob"]), "invalid test lockfile identity")
+        require(isinstance(expected_build["features"], str), "missing test features")
+        require(execution.get("run_id") == run["run_id"], "execution belongs to another run")
+        require(type(execution.get("exit_code")) is int and execution["exit_code"] == 0, "test command failed or did not run")
+        number(run["started_at"], "started_at", 1)
+        number(execution["finished_at"], "finished_at", run["started_at"])
+        for label in ("binary", "test_binary"):
+            require(sha(run[label]["sha256"]) and digest(Path(run[label]["path"])) == run[label]["sha256"],
+                    f"{label} changed or missing")
+        for name in ("listing.json", "junit.xml"):
+            path = directory / name
+            require(0 < path.stat().st_size <= MAX_JSON_BYTES, f"missing/oversized {name}")
+            require(run["started_at"] <= path.stat().st_mtime <= execution["finished_at"], f"{name} outside run window")
+            require(digest(path) == execution["artifacts"][name], f"{name} hash mismatch")
+        suites = read_json(directory / "listing.json")["rust-suites"]
+        xml = (directory / "junit.xml").read_bytes()
+        require(b"<!DOCTYPE" not in xml and b"<!ENTITY" not in xml, "JUnit entities are forbidden")
+        junit = ET.fromstring(xml)
+        cases = list(junit.iter("testcase"))
+        require(bool(cases), "JUnit has zero testcases")
+        for case in cases:
+            require(not any(child.tag in ("failure", "error", "skipped", "rerunFailure", "rerunError", "flakyFailure", "flakyError")
+                            for child in case), "JUnit contains failed, skipped or retried tests")
+        errors = []
+        for name, requirement in selected.items():
+            suite, test = requirement["suite"], requirement["name"]
+            for key in ("nodes", "drives_per_node"):
+                evidence_integer(requirement["topology"][key], f"required {key}", 1, 16)
+            listing_suite = suites[suite]
+            require(listing_suite["binary-id"] == suite, "nextest suite binary identity mismatch")
+            listed_binary = Path(listing_suite["binary-path"]).resolve(strict=True)
+            require(listed_binary == Path(run["test_binary"]["path"]).resolve(strict=True) and
+                    digest(listed_binary) == run["test_binary"]["sha256"], "nextest selected another test binary")
+            require(listing_suite["package-name"] == "e2e_test" and listing_suite["build-platform"] in ("host", "target"),
+                    "unexpected nextest suite metadata")
+            listed = listing_suite.get("testcases", {}).get(test, {})
+            require(listed.get("ignored") is False and listed.get("filter-match", {}).get("status") == "matches",
+                    f"required test not selected: {suite}::{test}")
+            matches = [case for case in cases if case.get("name") == test and case.get("classname") == suite]
+            require(len(matches) == 1, f"missing/duplicate JUnit case: {suite}::{test}")
+            started = datetime.fromisoformat(matches[0].attrib["timestamp"].replace("Z", "+00:00"))
+            require(started.tzinfo is not None, "JUnit timestamp must include timezone")
+            # quick-junit truncates timestamps to milliseconds.
+            require(run["started_at"] - 0.001 <= started.timestamp() <= execution["finished_at"],
+                    "JUnit testcase executed outside this run")
+            path = directory / requirement["oracle"]
+            require(path.resolve().is_relative_to(directory.resolve()), "oracle path escapes run directory")
+            require(run["started_at"] <= path.stat().st_mtime <= execution["finished_at"], "oracle outside run window")
+            require(digest(path) == execution["artifacts"][requirement["oracle"]], "oracle hash mismatch")
+            oracle = read_json(path)
+            evidence_integer(oracle.get("schema"), "oracle schema", 1, 1)
+            require(oracle.get("evidence") == "process-restart", "not real process-restart evidence")
+            require(oracle.get("case") == name and oracle.get("run_id") == run["run_id"], "oracle belongs to another case/run")
+            require(oracle.get("source_revision") == run["source_revision"], "oracle source mismatch")
+            built = oracle["test_build"]
+            for key in ("source_revision", "dirty", "lock_blob", "features"):
+                require(built[key] == expected_build[key], f"compiled test {key} mismatch")
+            require(built["dirty"] is False, "test binary was compiled from dirty source")
+            require(all(isinstance(built[key], str) and built[key] and built[key] != "unknown" for key in ("target", "profile")),
+                    "missing compiled target/profile")
+            require(isinstance(built["rustflags_hex"], str) and re.fullmatch(r"(?:[0-9a-f]{2})*", built["rustflags_hex"]) is not None,
+                    "invalid compiled rustflags")
+            for label in ("binary", "test_binary"):
+                require(oracle.get(f"{label}_sha256") == run[label]["sha256"], f"oracle {label} mismatch")
+            require(oracle.get("topology") == requirement["topology"], "oracle topology mismatch")
+            for key in ("nodes", "drives_per_node"):
+                evidence_integer(oracle["topology"][key], f"observed {key}", 1, 16)
+            evidence_integer(oracle.get("pid_before"), "pid_before", 1, 2**32 - 1)
+            evidence_integer(oracle.get("pid_after"), "pid_after", 1, 2**32 - 1)
+            require(oracle["pid_before"] != oracle["pid_after"], "no process restart witnessed")
+            objects = oracle["objects"]
+            require(isinstance(objects, list) and requirement["min_objects"] <= len(objects) <= requirement["max_objects"],
+                    "incomplete/oversized object oracle")
+            require(len({obj["key"] for obj in objects}) == len(objects), "duplicate object identity")
+            require(sum(obj["expected_physical"] is None for obj in objects) == 1,
+                    "only the outage object may lack a pre-fault target manifest")
+            for obj in objects:
+                require(isinstance(obj["key"], str) and 0 < len(obj["key"].encode()) <= 1024, "invalid object identity")
+                require(obj["version_id"] is None, "this case only covers unversioned objects")
+                require(type(obj["expected_bytes"]) is int and obj["expected_bytes"] > 0, "missing expected bytes")
+                require(type(obj["actual_bytes"]) is int and obj["actual_bytes"] == obj["expected_bytes"], "S3 body length mismatch")
+                require(sha(obj["expected_sha256"]) and obj["actual_sha256"] == obj["expected_sha256"], "S3 body digest mismatch")
+                physical = obj["physical"]
+                if obj["expected_physical"] is not None:
+                    require(physical == obj["expected_physical"], "target shard differs from pre-fault manifest")
+                for geometry in [physical] + ([obj["expected_physical"]] if obj["expected_physical"] is not None else []):
+                    data = evidence_integer(geometry["data_blocks"], "EC data blocks", 1, 16)
+                    parity = evidence_integer(geometry["parity_blocks"], "EC parity blocks", 1, 16)
+                    require(data + parity == oracle["topology"]["nodes"] * oracle["topology"]["drives_per_node"],
+                            "EC geometry differs from this case's single set")
+                    evidence_integer(geometry["erasure_index"], "target erasure index", 1, data + parity)
+                require(physical["has_xl_meta"] is True and physical["version_id"] is None, "missing target metadata")
+                parts = physical["expected_part_numbers"]
+                require(isinstance(parts, list) and 0 < len(parts) <= 10000, "no physical part coverage")
+                require(all(type(part) is int and part > 0 for part in parts) and len(set(parts)) == len(parts),
+                        "invalid physical part identity")
+                require({str(part) for part in parts} == set(physical["present_part_fingerprints"]), "target shard parts missing")
+                for part in physical["present_part_fingerprints"].values():
+                    require(type(part["size"]) is int and part["size"] > 0 and sha(part["sha256"]), "invalid target shard fingerprint")
+            node_listings = oracle["node_listings"]
+            require(isinstance(node_listings, list) and len(node_listings) == requirement["topology"]["nodes"],
+                    "missing per-node S3 listing")
+            require(all(keys == sorted(obj["key"] for obj in objects) for keys in node_listings),
+                    "S3 listing differs from object oracle")
+        if case_id == "release":
+            errors.extend(f"pending {gate}: {reason}" for gate, reason in registry["release_pending"].items())
+        return errors
+    except (OSError, KeyError, TypeError, ValueError, ET.ParseError) as error:
+        return [f"scanner/heal evidence rejected: {error}"]
+
+
 def validate(root: Path) -> list[str]:
     errors: list[str] = []
     errors.extend(check_core_fixtures(root))
@@ -1022,6 +1207,213 @@ class SelfTests(unittest.TestCase):
         with mock.patch(__name__ + ".check_quick_checks", return_value=[error]):
             self.assertIn(error, validate(ROOT))
 
+    def scanner_heal_fixture(self, directory: Path) -> tuple[Path, Path]:
+        """Parser fixtures only; these files are never runtime evidence."""
+        root, run_dir = directory / "repo", directory / "run"
+        (root / ".config").mkdir(parents=True)
+        run_dir.mkdir()
+        registry = read_json(ROOT / ".config/scanner-heal-required-tests.json")
+        write_json(root / ".config/scanner-heal-required-tests.json", registry)
+        requirement = registry["cases"]["background-target-restart"]
+        binary = directory / "fake-binary"
+        binary.write_bytes(b"parser fixture, not a real build")
+        binary.chmod(0o700)
+        build = {"path": str(binary), "sha256": digest(binary)}
+        write_json(run_dir / "run.json", {"schema": 1, "run_id": "a" * 32, "source_revision": "b" * 40,
+                                         "binary_source_revision": "b" * 40,
+                                         "test_build": {"source_revision": "b" * 40, "dirty": False,
+                                                        "lock_blob": "c" * 40, "features": "default"},
+                                         "started_at": datetime.now(timezone.utc).timestamp() - 1,
+                                         "binary": build, "test_binary": build})
+        write_json(run_dir / "listing.json", {"rust-suites": {requirement["suite"]: {
+            "binary-id": requirement["suite"], "binary-path": str(binary), "package-name": "e2e_test", "build-platform": "target",
+            "testcases": {
+            requirement["name"]: {"ignored": False, "filter-match": {"status": "matches"}}
+        }}}})
+        (run_dir / "junit.xml").write_text(
+            f'<testsuites><testsuite><testcase name="{requirement["name"]}" classname="{requirement["suite"]}" '
+            f'timestamp="{datetime.now(timezone.utc).isoformat(timespec="milliseconds")}"/></testsuite></testsuites>')
+        physical = {"has_xl_meta": True, "version_id": None, "data_dir": "data-generation",
+                    "erasure_index": 1, "data_blocks": 2, "parity_blocks": 2, "expected_part_numbers": [1],
+                    "present_part_fingerprints": {"1": {"size": 12, "sha256": "c" * 64}},
+                    "inline_data_fingerprint": None}
+        obj = {"key": "object", "version_id": None, "expected_bytes": 16, "actual_bytes": 16,
+               "expected_sha256": "d" * 64, "actual_sha256": "d" * 64,
+               "expected_physical": physical, "physical": physical}
+        objects = [dict(obj, key=f"object-{index}") for index in range(9)]
+        objects[-1] = dict(objects[-1], expected_physical=None)
+        write_json(run_dir / "background-target-restart.json", {
+            "schema": 1, "evidence": "process-restart", "case": "background-target-restart",
+            "run_id": "a" * 32, "source_revision": "b" * 40,
+            "test_build": {"source_revision": "b" * 40, "dirty": False, "lock_blob": "c" * 40,
+                           "features": "default", "target": "aarch64-apple-darwin", "profile": "debug", "rustflags_hex": ""},
+            "binary_sha256": build["sha256"], "test_binary_sha256": build["sha256"],
+            "topology": {"nodes": 4, "drives_per_node": 1}, "pid_before": 10, "pid_after": 11,
+            "objects": objects, "node_listings": [[item["key"] for item in objects]] * 4,
+        })
+        finish_scanner_heal_receipt(run_dir, 0)
+        return root, run_dir
+
+    def test_scanner_heal_case_does_not_approve_pending_release(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root, run_dir = self.scanner_heal_fixture(Path(tmp))
+            self.assertEqual(check_scanner_heal_evidence(root, run_dir, "background-target-restart"), [])
+            errors = check_scanner_heal_evidence(root, run_dir, "release")
+            self.assertEqual(len(errors), 21)
+            self.assertTrue(any(error.startswith("pending R-E:") for error in errors))
+            self.assertTrue(any(error.startswith("pending R-D:") for error in errors))
+            self.assertTrue(any(error.startswith("pending R-L:") for error in errors))
+
+    def test_scanner_heal_rejects_broken_execution_and_artifacts(self) -> None:
+        for fault in ("exit", "missing", "zero", "skipped", "failed", "retry", "filtered", "ignored", "stale",
+                      "hash", "binary", "synthetic", "wrong-run", "same-pid", "body", "parts", "listing", "topology"):
+            with self.subTest(fault=fault), tempfile.TemporaryDirectory() as tmp:
+                root, run_dir = self.scanner_heal_fixture(Path(tmp))
+                path = run_dir / "background-target-restart.json"
+                oracle = read_json(path)
+                if fault == "exit":
+                    receipt = read_json(run_dir / "execution.json")
+                    receipt["exit_code"] = 42
+                    write_json(run_dir / "execution.json", receipt)
+                elif fault == "missing":
+                    path.unlink()
+                elif fault == "zero":
+                    (run_dir / "junit.xml").write_text("<testsuites/>")
+                elif fault in ("skipped", "failed", "retry"):
+                    junit = run_dir / "junit.xml"
+                    tag = {"skipped": "skipped", "failed": "failure", "retry": "rerunFailure"}[fault]
+                    junit.write_text(junit.read_text().replace("/></testsuite>", f"><{tag}/></testcase></testsuite>"))
+                elif fault in ("filtered", "ignored"):
+                    listing = read_json(run_dir / "listing.json")
+                    case = next(iter(listing["rust-suites"]["e2e_test"]["testcases"].values()))
+                    case["ignored"] = fault == "ignored"
+                    case["filter-match"]["status"] = "mismatch" if fault == "filtered" else "matches"
+                    write_json(run_dir / "listing.json", listing)
+                elif fault == "stale":
+                    os.utime(path, (1, 1))
+                elif fault == "hash":
+                    path.write_text(path.read_text() + " ")
+                elif fault == "binary":
+                    Path(read_json(run_dir / "run.json")["binary"]["path"]).write_bytes(b"another build")
+                else:
+                    if fault == "synthetic":
+                        oracle["evidence"] = "synthetic"
+                    elif fault == "wrong-run":
+                        oracle["run_id"] = "f" * 32
+                    elif fault == "same-pid":
+                        oracle["pid_after"] = oracle["pid_before"]
+                    elif fault == "body":
+                        oracle["objects"][0]["actual_sha256"] = "e" * 64
+                    elif fault == "parts":
+                        oracle["objects"][0]["physical"]["present_part_fingerprints"] = {}
+                    elif fault == "listing":
+                        oracle["node_listings"][0] = []
+                    elif fault == "topology":
+                        oracle["topology"] = {"nodes": 3, "drives_per_node": 4}
+                    write_json(path, oracle)
+                if fault not in ("exit", "missing", "stale", "hash", "binary"):
+                    (run_dir / "execution.json").unlink()
+                    finish_scanner_heal_receipt(run_dir, 0)
+                self.assertTrue(check_scanner_heal_evidence(root, run_dir, "background-target-restart"), fault)
+
+    def test_scanner_heal_receipts_reject_reuse_and_missing_builds(self) -> None:
+        with tempfile.TemporaryDirectory() as tmp:
+            root, run_dir = self.scanner_heal_fixture(Path(tmp))
+            with self.assertRaisesRegex(ValueError, "already exists"):
+                finish_scanner_heal_receipt(run_dir, 0)
+            with self.assertRaisesRegex(ValueError, "must be new"):
+                begin_scanner_heal_receipt(root, run_dir, Path("missing"), Path("missing"))
+            with mock.patch("subprocess.check_output", side_effect=["", "b" * 40]):
+                with self.assertRaises(FileNotFoundError):
+                    begin_scanner_heal_receipt(root, Path(tmp) / "new-run", Path(tmp) / "missing", Path(tmp) / "missing")
+
+    def test_scanner_heal_begin_requires_embedded_source_provenance(self) -> None:
+        for kind in ("current", "stale", "dirty", "unknown"):
+            with self.subTest(kind=kind), tempfile.TemporaryDirectory() as tmp:
+                root, _ = self.scanner_heal_fixture(Path(tmp))
+                sources = root / "crates/e2e_test/src"
+                sources.mkdir(parents=True)
+                (sources / "heal_erasure_disk_rebuild_test.rs").write_bytes(b"oracle source")
+                (sources / "chaos.rs").write_bytes(b"census source")
+                revision = "c" * 40 if kind == "stale" else "b" * 40
+                version = f"rustfs\ngit commit   : {revision}\ngit status   :\n"
+                if kind == "dirty":
+                    version += "modified source\n"
+                if kind == "unknown":
+                    version = "rustfs without build provenance"
+                with mock.patch("subprocess.check_output", side_effect=["", "b" * 40, version, "c" * 40]), \
+                     mock.patch.dict(os.environ, {"RUSTFS_E2E_EXPECTED_FEATURES": "default"}):
+                    directory = Path(tmp) / "fresh"
+                    binary = Path(tmp) / "fake-binary"
+                    if kind == "current":
+                        begin_scanner_heal_receipt(root, directory, binary, binary)
+                        self.assertEqual(read_json(directory / "run.json")["binary_source_revision"], "b" * 40)
+                    else:
+                        with self.assertRaisesRegex(ValueError, "server binary"):
+                            begin_scanner_heal_receipt(root, directory, binary, binary)
+                        self.assertFalse(directory.exists())
+
+    def test_scanner_heal_rejects_copied_junit_and_wrong_suite_build(self) -> None:
+        for fault in ("old-junit", "missing-time", "wrong-binary", "common-source", "lockfile", "features", "dirty-build"):
+            with self.subTest(fault=fault), tempfile.TemporaryDirectory() as tmp:
+                root, run_dir = self.scanner_heal_fixture(Path(tmp))
+                if fault in ("old-junit", "missing-time"):
+                    path = run_dir / "junit.xml"
+                    xml = ET.fromstring(path.read_bytes())
+                    testcase = next(xml.iter("testcase"))
+                    if fault == "old-junit":
+                        testcase.set("timestamp", "2000-01-01T00:00:00.000Z")
+                    else:
+                        del testcase.attrib["timestamp"]
+                    # Rewriting/copying gives an old execution a fresh mtime.
+                    path.write_bytes(ET.tostring(xml))
+                elif fault == "wrong-binary":
+                    path = run_dir / "listing.json"
+                    listing = read_json(path)
+                    another = Path(tmp) / "another-binary"
+                    another.write_bytes(Path(tmp, "fake-binary").read_bytes())
+                    listing["rust-suites"]["e2e_test"]["binary-path"] = str(another)
+                    write_json(path, listing)
+                else:
+                    path = run_dir / "background-target-restart.json"
+                    oracle = read_json(path)
+                    key, value = {"common-source": ("source_revision", "f" * 40), "lockfile": ("lock_blob", "f" * 40),
+                                  "features": ("features", "default,sftp"), "dirty-build": ("dirty", True)}[fault]
+                    oracle["test_build"][key] = value
+                    write_json(path, oracle)
+                (run_dir / "execution.json").unlink()
+                finish_scanner_heal_receipt(run_dir, 0)
+                self.assertTrue(check_scanner_heal_evidence(root, run_dir, "background-target-restart"), fault)
+
+    def test_scanner_heal_rejects_boolean_fractional_and_out_of_geometry_integers(self) -> None:
+        valid = {"schema": 1, "nodes": 4, "drives_per_node": 1, "pid_before": 10, "pid_after": 11,
+                 "erasure_index": 1, "data_blocks": 2, "parity_blocks": 2}
+        cases = [(field, value) for field, correct in valid.items() for value in (True, float(correct))]
+        cases += [("erasure_index", 5), ("erasure_index", 0), ("pid_after", -1)]
+        for field, value in cases:
+            with self.subTest(field=field, value=value), tempfile.TemporaryDirectory() as tmp:
+                root, run_dir = self.scanner_heal_fixture(Path(tmp))
+                path = run_dir / "background-target-restart.json"
+                oracle = read_json(path)
+                if field in ("nodes", "drives_per_node"):
+                    oracle["topology"][field] = value
+                elif field in ("erasure_index", "data_blocks", "parity_blocks"):
+                    oracle["objects"][-1]["physical"][field] = value
+                else:
+                    oracle[field] = value
+                write_json(path, oracle)
+                (run_dir / "execution.json").unlink()
+                finish_scanner_heal_receipt(run_dir, 0)
+                self.assertTrue(check_scanner_heal_evidence(root, run_dir, "background-target-restart"))
+        for filename in ("run.json", ".config/scanner-heal-required-tests.json"):
+            with self.subTest(filename=filename), tempfile.TemporaryDirectory() as tmp:
+                root, run_dir = self.scanner_heal_fixture(Path(tmp))
+                path = (root if filename.startswith(".config") else run_dir) / filename
+                content = read_json(path)
+                content["schema"] = True
+                write_json(path, content)
+                self.assertTrue(check_scanner_heal_evidence(root, run_dir, "background-target-restart"))
+
     def test_core_gate_rejects_missing_ignored_filtered_and_corrupt_inputs(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root = Path(tmp)
@@ -1664,6 +2056,25 @@ def main() -> int:
     if sys.argv[1:] == ["--self-test"]:
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(SelfTests)
         return 0 if unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful() else 1
+    if sys.argv[1:2] in (["--begin-scanner-heal"], ["--finish-scanner-heal"], ["--check-scanner-heal"]):
+        try:
+            if len(sys.argv) == 5 and sys.argv[1] == "--begin-scanner-heal":
+                begin_scanner_heal_receipt(ROOT, Path(sys.argv[2]), Path(sys.argv[3]), Path(sys.argv[4]))
+                return 0
+            if len(sys.argv) == 4 and sys.argv[1] == "--finish-scanner-heal":
+                finish_scanner_heal_receipt(Path(sys.argv[2]), int(sys.argv[3]))
+                return 0
+            if len(sys.argv) == 4 and sys.argv[1] == "--check-scanner-heal":
+                errors = check_scanner_heal_evidence(ROOT, Path(sys.argv[2]), sys.argv[3])
+                for error in errors:
+                    print(f"ERROR: {error}", file=sys.stderr)
+                if not errors:
+                    print(f"Case evidence verified: {sys.argv[3]}; this does not approve release")
+                return 1 if errors else 0
+            raise ValueError("expected --begin-scanner-heal DIR BINARY TEST_BINARY, --finish-scanner-heal DIR EXIT, or --check-scanner-heal DIR CASE|release")
+        except (OSError, KeyError, TypeError, ValueError, subprocess.SubprocessError) as error:
+            print(f"ERROR: {error}", file=sys.stderr)
+            return 1
     if len(sys.argv) == 3 and sys.argv[1] == "--check-core":
         errors = check_core_listing(ROOT, Path(sys.argv[2]))
         for error in errors:

scripts/run_scanner_validation_harness.sh

@@ -1,6 +1,12 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
+if [[ "${1:-}" == "--abba" ]]; then
+  shift
+  SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+  exec "$SCRIPT_DIR/python_bin.sh" "$SCRIPT_DIR/scanner_abba.py" "$@"
+fi
+
 ALIAS=""
 ENDPOINT=""
 ACCESS_KEY="${RUSTFS_ACCESS_KEY:-}"
@@ -23,6 +29,7 @@ TELEMETRY_PIDS=()
 usage() {
   cat <<'USAGE'
 Usage:
+  scripts/run_scanner_validation_harness.sh --abba --help
   scripts/run_scanner_validation_harness.sh --alias <admin-alias> \
     --endpoint <url> [options]
 

scripts/scanner_abba.py

@@ -0,0 +1,446 @@
+#!/usr/bin/env python3
+"""Run isolated scanner/heal ABBA cells through a deployment-specific adapter."""
+
+import argparse
+from decimal import Decimal
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import select
+import shutil
+import signal
+import subprocess
+import sys
+import time
+
+SCENARIOS = ("cold-hot", "fresh-hot", "multi-hot-new", "running-heal", "mrf-replay")
+LEGS = ("A1", "B1", "B2", "A2")
+MAX_JSON_BYTES = 1024 * 1024
+METRICS = (
+    "p99_ms", "throughput_ops", "rss_bytes", "cpu_seconds", "iops", "rpc_count",
+    "cache_clone_bytes", "encode_bytes", "save_bytes", "oldest_age_seconds",
+    "walk_objects", "cold_walk_objects", "healed_objects", "errors", "requests",
+)
+REPEATABILITY_LIMIT = Decimal("0.05")
+P2_WORK_MULTIPLE_LIMIT = Decimal("1.2")
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def number(value, name, minimum=0):
+    require(type(value) in (float, int) and math.isfinite(value) and value >= minimum,
+            f"invalid {name}")
+    return value
+
+
+def decimal_number(value, name, minimum=0):
+    if isinstance(value, Decimal):
+        require(value.is_finite() and value >= Decimal(str(minimum)), f"invalid {name}")
+        return value
+    number(value, name, minimum)
+    return Decimal(str(value))
+
+
+def ratio(numerator, denominator, name):
+    denominator = decimal_number(denominator, f"{name} denominator")
+    require(denominator > 0, f"invalid {name} denominator")
+    return decimal_number(numerator, name) / denominator
+
+
+def relative_change(current, baseline, name):
+    return ratio(current, baseline, name) - Decimal("1")
+
+
+def repeatability_change(first, second, name):
+    first = decimal_number(first, name)
+    second = decimal_number(second, name)
+    if first == 0 and second == 0:
+        return Decimal("0")
+    if first == 0 or second == 0:
+        return Decimal("Infinity")
+    return abs(second / first - Decimal("1"))
+
+
+def report_number(value):
+    return None if value.is_infinite() else float(value)
+
+
+def digest(path):
+    with Path(path).open("rb") as stream:
+        return hashlib.file_digest(stream, "sha256").hexdigest()
+
+
+def read_json(path):
+    require(path.stat().st_size <= MAX_JSON_BYTES, f"oversized JSON: {path.name}")
+    with path.open() as stream:
+        value = json.load(stream)
+    require(isinstance(value, dict), f"expected JSON object: {path.name}")
+    return value
+
+
+def write_json(path, value):
+    data = json.dumps(value, indent=2, allow_nan=False) + "\n"
+    require(len(data.encode()) <= MAX_JSON_BYTES, "oversized result")
+    path.write_text(data)
+
+
+def sha(value):
+    return isinstance(value, str) and len(value) == 64 and all(c in "0123456789abcdef" for c in value)
+
+
+def validate_manifest(manifest):
+    require(manifest.get("schema") == 1, "unsupported manifest schema")
+    require(manifest.get("evidence") in ("synthetic", "measured"), "missing evidence type")
+    fixed = manifest["fixed"]
+    for key in ("config_sha256", "dataset_sha256"):
+        require(sha(fixed.get(key)), f"invalid fixed.{key}")
+    for key in ("release_flags", "durability", "disk_type", "cache_state", "load_command", "resource_isolation"):
+        require(isinstance(fixed.get(key), str) and fixed[key].strip(), f"missing fixed.{key}")
+    require(fixed.get("topology") == "EC8+4", "formal matrix requires EC8+4")
+    number(fixed.get("offered_load_ops"), "offered load", 1)
+    require(type(manifest.get("rounds")) is int and 3 <= manifest["rounds"] <= 10,
+            "rounds must be 3..10")
+    minimum = 900 if manifest["evidence"] == "measured" else 1
+    require(type(manifest.get("duration_seconds")) is int and
+            minimum <= manifest["duration_seconds"] <= 86400, "invalid duration_seconds")
+    number(manifest.get("min_free_bytes"), "min_free_bytes", 1)
+    for phase in ("baseline", "candidate"):
+        build = manifest[phase]
+        path = Path(build["binary"]).resolve(strict=True)
+        require(path.is_file() and os.access(path, os.X_OK), f"missing executable {phase} build")
+        require(sha(build.get("sha256")) and digest(path) == build["sha256"], f"{phase} binary hash mismatch")
+        require(isinstance(build.get("revision"), str) and len(build["revision"]) == 40 and
+                all(c in "0123456789abcdef" for c in build["revision"]), f"invalid {phase} revision")
+        build["binary"] = str(path)
+    for scenario in SCENARIOS:
+        expected = manifest["oracles"][scenario]
+        for key in ("objects", "versions", "bytes"):
+            require(type(expected.get(key)) is int and expected[key] > 0, f"missing {scenario} oracle {key}")
+        require(sha(expected.get("sha256")), f"missing {scenario} content/version digest")
+        number(manifest["expected_healed_objects"].get(scenario), f"{scenario} expected repairs")
+        if scenario in ("running-heal", "mrf-replay"):
+            require(manifest["expected_healed_objects"][scenario] > 0, f"{scenario} requires repairs")
+
+
+class OwnedCommand:
+    """Keep the session leader unreaped until its group's last signal is sent."""
+
+    def __init__(self, args, log):
+        require(sys.platform == "darwin" or hasattr(os, "waitid"), "non-reaping child observation is unavailable")
+        self.args, self.status = args, None
+        self.queue = select.kqueue() if sys.platform == "darwin" else None
+        self.process = None
+        read_gate, write_gate = os.pipe()
+        try:
+            # The shell has already exec'd when Popen returns. Gate the target
+            # until kqueue is registered; preexec_fn would deadlock Popen here.
+            gate = f'read -r _scanner_gate <&{read_gate} || exit 125; exec {read_gate}<&-; exec "$@"'
+            self.process = subprocess.Popen(["bash", "-c", gate, "scanner-abba", *args], pass_fds=(read_gate,),
+                                            stdout=log, stderr=subprocess.STDOUT, start_new_session=True)
+            if self.queue is not None:
+                # Darwin NOTE_EXITSTATUS is not exposed by Python's select constants.
+                event = select.kevent(self.process.pid, filter=select.KQ_FILTER_PROC,
+                                      flags=select.KQ_EV_ADD | select.KQ_EV_ONESHOT,
+                                      fflags=select.KQ_NOTE_EXIT | 0x04000000)
+                self.queue.control([event], 0, 0)
+            os.write(write_gate, b"\n")
+        except BaseException:
+            try:
+                if self.process is not None:
+                    try:
+                        self._signal_group(signal.SIGKILL)
+                    finally:
+                        self.process.wait(timeout=10)
+            finally:
+                if self.queue is not None:
+                    self.queue.close()
+            raise
+        finally:
+            os.close(read_gate)
+            os.close(write_gate)
+
+    def wait(self, timeout):
+        if self.status is not None:
+            return self.status
+        deadline = time.monotonic() + timeout
+        while True:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise subprocess.TimeoutExpired(self.args, timeout)
+            if self.queue is not None:
+                events = self.queue.control(None, 1, remaining)
+                if events:
+                    self.status = os.waitstatus_to_exitcode(events[0].data)
+                    return self.status
+            else:
+                result = os.waitid(os.P_PID, self.process.pid, os.WEXITED | os.WNOWAIT | os.WNOHANG)
+                if result is not None:
+                    self.status = result.si_status if result.si_code == os.CLD_EXITED else -result.si_status
+                    return self.status
+                time.sleep(min(0.05, remaining))
+
+    def _signal_group(self, sig):
+        try:
+            os.killpg(self.process.pid, sig)
+            return True
+        except ProcessLookupError:
+            return False
+
+    def finish(self, terminate=False):
+        if self.process.returncode is not None:
+            return self.process.returncode
+        try:
+            if terminate:
+                try:
+                    self._signal_group(signal.SIGTERM)
+                    deadline = time.monotonic() + 10
+                    while time.monotonic() < deadline and self._signal_group(0):
+                        time.sleep(0.05)
+                finally:
+                    # Keep the PID reserved through the last group signal, even
+                    # when the cleanup grace period itself is interrupted.
+                    self._signal_group(signal.SIGKILL)
+        finally:
+            try:
+                returncode = self.process.wait(timeout=10)
+            finally:
+                if self.queue is not None:
+                    self.queue.close()
+        return returncode
+
+
+def invoke(adapter, action, request, timeout):
+    """The adapter writes bounded JSON separately; stderr/stdout remain raw evidence."""
+    output = request.parent / f"{action}.json"
+    with (request.parent / f"{action}.log").open("wb") as log:
+        process = OwnedCommand([str(adapter), action, str(request), str(output)], log)
+        try:
+            returncode = process.wait(timeout)
+            if returncode:
+                raise subprocess.CalledProcessError(returncode, [str(adapter), action])
+            result = read_json(output)
+        except BaseException:
+            process.finish(terminate=True)
+            raise
+        else:
+            # Successful prepare may intentionally leave adapter-owned services.
+            process.finish()
+            return result
+
+
+def validate_result(result, request, expected):
+    require(result.get("evidence") == request["evidence"], "adapter evidence type mismatch")
+    require(result.get("fixed") == request["fixed"], "offered load/config/cache/durability drift")
+    require(result.get("build") == request["build"], "deployed build provenance mismatch")
+    require(result.get("data_dir") == request["data_dir"], "adapter data isolation mismatch")
+    require(result.get("background") == request["background"], "background mode mismatch")
+    require(type(result.get("sample_count")) is int and 1 <= result["sample_count"] <= 3600,
+            "sample_count must be 1..3600")
+    number(result.get("elapsed_seconds"), "elapsed_seconds", request["duration_seconds"])
+    metrics = result["metrics"]
+    for key in METRICS:
+        number(metrics.get(key), key)
+    for key in ("requests", "p99_ms", "throughput_ops"):
+        require(metrics[key] > 0, f"zero {key}")
+    require(metrics["errors"] == 0, "workload request errors")
+    require(metrics["cold_walk_objects"] <= metrics["walk_objects"], "cold walk exceeds total walk")
+    require(result.get("oracle") == expected, "object/version/byte oracle mismatch")
+    if request["background"] == "on":
+        require(metrics["walk_objects"] > 0, "zero background walk")
+        require(metrics["healed_objects"] == request["expected_healed_objects"], "incomplete repair oracle")
+        if request["scenario"] in ("running-heal", "mrf-replay"):
+            require(metrics["healed_objects"] > 0, "zero completed repairs")
+    return result
+
+
+def convergence(result):
+    window = result.get("convergence")
+    if not window or window.get("writes_stopped") is not True or window.get("last_mutation_observed") is not True or window.get("first_complete_publication") is not True:
+        return None
+    for key in ("last_mutation_time", "last_mutation_observed_time", "writes_stopped_time", "window_start", "window_end", "walk_objects", "full_walk_objects", "budget_available_seconds"):
+        number(window.get(key), f"convergence.{key}")
+    require(window["last_mutation_time"] <= window["writes_stopped_time"] <= window["window_start"] < window["window_end"],
+            "invalid post-mutation convergence window")
+    require(window["last_mutation_time"] <= window["last_mutation_observed_time"] <= window["window_start"],
+            "convergence started before last mutation was observed")
+    require(window["full_walk_objects"] > 0, "zero full walk reference")
+    require(0 < window["budget_available_seconds"] <= window["window_end"] - window["window_start"],
+            "invalid convergence budget window")
+    return ratio(window["walk_objects"], window["full_walk_objects"], "convergence work")
+
+
+def evaluate(cells):
+    comparisons = []
+    inconclusive = False
+    failed = False
+    for offset in range(0, len(cells), 4):
+        group = cells[offset:offset + 4]
+        require([cell["leg"] for cell in group] == list(LEGS), "incomplete ABBA group")
+        a1, b1, b2, a2 = (cell["result"]["metrics"] for cell in group)
+        control = group[0]["comparison"] == "background"
+        drift = max(abs(relative_change(a2[k], a1[k], k)) for k in ("p99_ms", "throughput_ops"))
+        repeat_drift = max(abs(relative_change(b2[k], b1[k], k)) for k in ("p99_ms", "throughput_ops"))
+        noise = max(drift, repeat_drift) > REPEATABILITY_LIMIT
+        a = {key: (decimal_number(a1[key], key) + decimal_number(a2[key], key)) / Decimal("2") for key in METRICS}
+        b = {key: (decimal_number(b1[key], key) + decimal_number(b2[key], key)) / Decimal("2") for key in METRICS}
+        p99 = relative_change(b["p99_ms"], a["p99_ms"], "p99_ms")
+        throughput = relative_change(b["throughput_ops"], a["throughput_ops"], "throughput_ops")
+        thresholds = {"p99_regression": Decimal("0.10") if control else Decimal("0.05"),
+                      "throughput_loss": Decimal("0.05") if control else Decimal("0.03")}
+        passed = p99 <= thresholds["p99_regression"] and throughput >= -thresholds["throughput_loss"]
+        p1 = None
+        work_drift = None
+        if not control:
+            if group[0]["scenario"] == "cold-hot":
+                require(a["cold_walk_objects"] > 0, "cold-hot baseline has no cold walk samples")
+            work_drift = max(repeatability_change(a1[key], a2[key], key) for key in ("walk_objects", "cold_walk_objects"))
+            work_drift = max(work_drift, *(repeatability_change(b1[key], b2[key], key) for key in ("walk_objects", "cold_walk_objects")))
+            noise |= work_drift > REPEATABILITY_LIMIT
+            required = ratio(a["cold_walk_objects"], a["walk_objects"], "cold walk baseline") * Decimal("0.80")
+            reduction = Decimal("1") - ratio(b["walk_objects"], a["walk_objects"], "walk reduction")
+            p1 = {"required_reduction": float(required), "observed_reduction": float(reduction),
+                  "repeatability_drift": report_number(work_drift)}
+            if group[0]["scenario"] == "cold-hot":
+                # Compare counts before division can round repeating decimal ratios.
+                passed &= a["walk_objects"] - b["walk_objects"] >= a["cold_walk_objects"] * Decimal("0.80")
+        p2 = [convergence(cell["result"]) if cell["background"] == "on" else None for cell in group]
+        candidate_p2 = [value for cell, value in zip(group, p2) if cell["leg"].startswith("B")]
+        p2_pending = any(value is None for value in candidate_p2)
+        passed &= all(ratio(value, 1, "p2 work multiple") <= P2_WORK_MULTIPLE_LIMIT for value in candidate_p2 if value is not None)
+        p2_report = [None if value is None else float(value) for value in p2]
+        inconclusive |= noise or p2_pending
+        if not noise and not passed:
+            failed = True
+        comparisons.append({"scenario": group[0]["scenario"], "comparison": group[0]["comparison"],
+                            "round": group[0]["round"], "status": "inconclusive" if noise else ("fail" if not passed else "inconclusive" if p2_pending else "pass"),
+                            "a2_a1_drift": report_number(drift), "b2_b1_drift": report_number(repeat_drift),
+                            "p99_regression": float(p99), "throughput_change": float(throughput),
+                            "thresholds": {key: float(value) for key, value in thresholds.items()},
+                            "p1": p1, "p2_max_work_multiple": float(P2_WORK_MULTIPLE_LIMIT),
+                            "p2_post_stop_work_multiples": p2_report})
+    return ("fail" if failed else "inconclusive" if inconclusive else "pass"), comparisons
+
+
+def collect_live(prepared, request, request_path, adapter):
+    collector = Path(__file__).with_name("run_scanner_validation_harness.sh")
+    # Only allow connection fields here; the runner owns cadence and output paths.
+    connection = prepared["collector"]
+    require(set(connection) == {"alias", "endpoint", "metrics_endpoints"}, "invalid collector connection")
+    require(all(isinstance(value, str) and value for value in connection.values()), "missing collector endpoint")
+    output = request_path.parent / "telemetry"
+    args = ["bash", str(collector), "--alias", connection["alias"], "--endpoint", connection["endpoint"],
+            "--metrics-endpoints", connection["metrics_endpoints"], "--deployment", "distributed",
+            "--samples", str(request["duration_seconds"] // 60 + 1), "--interval-secs", "60",
+            "--out-dir", str(output)]
+    with (request_path.parent / "collector.log").open("wb") as log:
+        process = OwnedCommand(args, log)
+        try:
+            started = time.monotonic()
+            result = invoke(adapter, "measure", request_path, request["duration_seconds"] + 300)
+            require(time.monotonic() - started >= request["duration_seconds"], "measurement ended before required window")
+            require(process.wait(120) == 0, "scanner collector failed")
+            require(output.joinpath("scanner-summary.csv").stat().st_size > 0, "missing collector samples")
+            samples = list((output / "status").glob("scanner-status.*.json"))
+            require(len(samples) == request["duration_seconds"] // 60 + 1, "missing scanner samples")
+            for sample in samples:
+                status = read_json(sample)
+                require(isinstance(status.get("metrics"), dict) and status["metrics"], "invalid scanner status response")
+            heals = list((output / "heal").glob("background-heal-status.*.json"))
+            require(bool(heals), "missing heal samples")
+            for sample in heals:
+                status = read_json(sample)
+                require(isinstance(status.get("healOperations"), dict) and status["healOperations"], "invalid heal status response")
+            return result
+        finally:
+            process.finish(terminate=True)
+
+
+def run(manifest, adapter, output, data_root):
+    validate_manifest(manifest)
+    require(adapter.is_file() and os.access(adapter, os.X_OK), "missing executable adapter")
+    require(not output.exists() and not data_root.exists(), "output/data root must be new; existing data is preserved")
+    require(output != data_root and output not in data_root.parents and data_root not in output.parents,
+            "output and data roots must not overlap")
+    output.mkdir(parents=True)
+    data_root.mkdir(parents=True)
+    require(shutil.disk_usage(data_root).free >= manifest["min_free_bytes"], "insufficient free disk space")
+    manifest["adapter_sha256"] = digest(adapter)
+    manifest["collector_sha256"] = digest(Path(__file__).with_name("run_scanner_validation_harness.sh"))
+    write_json(output / "manifest.json", manifest)
+    cells = []
+    write_json(output / "report.json", {"status": "incomplete", "performance": "pending"})
+    try:
+        for scenario in SCENARIOS:
+            for comparison in ("build", "background"):
+                for round_id in range(1, manifest["rounds"] + 1):
+                    for leg in LEGS:
+                        phase = "baseline" if comparison == "build" and leg.startswith("A") else "candidate"
+                        background = "off" if comparison == "background" and leg.startswith("A") else "on"
+                        name = f"{scenario}-{comparison}-{round_id}-{leg}"
+                        cell_dir = output / name
+                        cell_dir.mkdir()
+                        data_dir = data_root / name
+                        data_dir.mkdir()
+                        request = {"schema": 1, "scenario": scenario, "comparison": comparison, "round": round_id,
+                                   "leg": leg, "background": background, "build": manifest[phase],
+                                   "evidence": manifest["evidence"], "fixed": manifest["fixed"],
+                                   "duration_seconds": manifest["duration_seconds"], "data_dir": str(data_dir),
+                                   "expected_healed_objects": manifest["expected_healed_objects"][scenario],
+                                   "expected_oracle": manifest["oracles"][scenario]}
+                        require(digest(Path(request["build"]["binary"])) == request["build"]["sha256"], "binary changed during run")
+                        require(digest(adapter) == manifest["adapter_sha256"], "adapter changed during run")
+                        require(shutil.disk_usage(data_root).free >= manifest["min_free_bytes"], "insufficient free disk space")
+                        request_path = cell_dir / "request.json"
+                        write_json(request_path, request)
+                        print(name, flush=True)
+                        try:
+                            prepared = invoke(adapter, "prepare", request_path, 300)
+                            require(prepared.get("ready") is True, "deployment not ready")
+                            if manifest["evidence"] == "measured":
+                                result = collect_live(prepared, request, request_path, adapter)
+                            else:
+                                result = invoke(adapter, "measure", request_path, 300)
+                            # An independent operation must enumerate all object versions and bytes.
+                            oracle = invoke(adapter, "oracle", request_path, 300)
+                            require(oracle.get("complete") is True and oracle.get("errors") == 0, "correctness oracle failed")
+                            require(type(oracle.get("errors")) is int, "invalid oracle error count")
+                            result["oracle"] = oracle["actual"]
+                            validate_result(result, request, request["expected_oracle"])
+                            cells.append({**request, "result": result})
+                        finally:
+                            stopped = invoke(adapter, "stop", request_path, 300)
+                            require(stopped.get("stopped") is True, "adapter failed to stop deployment")
+        status, comparisons = evaluate(cells)
+        synthetic = manifest["evidence"] == "synthetic"
+        report = {"status": "synthetic_validated" if synthetic and status == "pass" else status,
+                  "evidence": manifest["evidence"], "performance": "pending" if synthetic else status,
+                  "cells": len(cells), "comparisons": comparisons}
+        write_json(output / "report.json", report)
+        return 0 if status == "pass" else 3 if status == "inconclusive" else 1
+    except (ValueError, KeyError, OSError, subprocess.SubprocessError) as error:
+        write_json(output / "report.json", {"status": "failed", "performance": "pending",
+                                            "completed_cells": len(cells), "error": str(error)})
+        raise
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--manifest", type=Path, required=True)
+    parser.add_argument("--adapter", type=Path, required=True)
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument("--data-root", type=Path, required=True)
+    args = parser.parse_args()
+    try:
+        return run(read_json(args.manifest), args.adapter.resolve(), args.out_dir.resolve(), args.data_root.resolve())
+    except (ValueError, KeyError, OSError, subprocess.SubprocessError) as error:
+        print(f"ERROR: {error}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/test_scanner_abba.py

@@ -0,0 +1,360 @@
+#!/usr/bin/env python3
+"""Synthetic adapter and failure-propagation tests; never start a RustFS server."""
+
+import contextlib
+import copy
+import fcntl
+import io
+import json
+import os
+from pathlib import Path
+import shlex
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from unittest.mock import patch
+
+import scanner_abba as harness
+
+
+def fake_adapter():
+    action, request_path, output_path = sys.argv[1:]
+    request = harness.read_json(Path(request_path))
+    fault = os.environ.get("SCANNER_ABBA_TEST_FAULT", "")
+    if fault == "stubborn-child" and action in ("prepare", "measure"):
+        marker = Path(request_path).parent / "stubborn.pid"
+        if os.fork() == 0:
+            os.execv(sys.executable, [sys.executable, str(Path(__file__).resolve()), "--stubborn-worker", str(marker)])
+        wait_for_marker(marker)
+        if action == "measure":
+            time.sleep(60)
+    if action == "prepare":
+        result = {"ready": True}
+    elif action == "stop":
+        if fault == "stubborn-child":
+            reap_fixture(Path(request_path).parent / "stubborn.pid")
+        result = {"stopped": True}
+    elif action == "oracle":
+        if fault == "oracle-exit":
+            return 42
+        if fault == "missing-oracle":
+            return 0
+        result = {"complete": True, "errors": 0, "actual": request["expected_oracle"]}
+        if fault == "oracle-mismatch":
+            result["actual"]["bytes"] += 1
+    else:
+        if fault == "measure-exit":
+            return 42
+        result = {key: request[key] for key in ("evidence", "fixed", "build", "data_dir", "background")}
+        result.update({"sample_count": 10, "elapsed_seconds": request["duration_seconds"],
+                       "metrics": dict.fromkeys(harness.METRICS, 10)})
+        baseline = request["comparison"] == "build" and request["leg"].startswith("A")
+        result["metrics"].update(p99_ms=10, throughput_ops=100, errors=0, requests=100,
+                                 walk_objects=100 if baseline else 20, cold_walk_objects=100 if baseline else 0,
+                                 healed_objects=request["expected_healed_objects"])
+        result["convergence"] = {"writes_stopped": True, "last_mutation_observed": True,
+                                 "first_complete_publication": True, "last_mutation_time": 1,
+                                 "last_mutation_observed_time": 2,
+                                 "writes_stopped_time": 2, "window_start": 2, "window_end": 3,
+                                 "budget_available_seconds": 1, "walk_objects": 110, "full_walk_objects": 100}
+        if fault == "zero-samples":
+            result["sample_count"] = 0
+        elif fault == "request-errors":
+            result["metrics"]["errors"] = 1
+        elif fault == "load-drift":
+            result["fixed"]["offered_load_ops"] += 1
+        elif fault == "noise" and request["leg"] == "A2":
+            result["metrics"]["p99_ms"] = 20
+        elif fault == "zero-requests":
+            result["metrics"]["requests"] = 0
+        elif fault == "no-publication":
+            result["convergence"]["first_complete_publication"] = False
+        elif fault == "p2-regression":
+            result["convergence"]["walk_objects"] = 121
+        elif fault == "latency-regression" and request["leg"].startswith("B"):
+            result["metrics"]["p99_ms"] = 12
+        elif fault == "exact-thresholds" and request["leg"].startswith("B"):
+            result["metrics"].update(p99_ms=10.5, throughput_ops=97)
+        elif fault == "just-over-threshold" and request["comparison"] == "build" and request["leg"].startswith("B"):
+            result["metrics"]["p99_ms"] = 10.500001
+        elif fault == "p1-regression" and not baseline:
+            result["metrics"]["walk_objects"] = 30
+        elif fault in ("p1-exact-fraction", "p1-over-fraction"):
+            result["metrics"].update(walk_objects=9 if baseline else 5 + (fault == "p1-over-fraction"),
+                                     cold_walk_objects=5 if baseline else 0)
+        elif fault == "missing-metric":
+            del result["metrics"]["save_bytes"]
+        elif fault == "incomplete-repair":
+            result["metrics"]["healed_objects"] = 0
+    harness.write_json(Path(output_path), result)
+    return 0
+
+
+def wait_for_marker(marker):
+    deadline = time.monotonic() + 5
+    while time.monotonic() < deadline:
+        if marker.exists() and marker.stat().st_size:
+            return
+        time.sleep(0.01)
+    raise AssertionError("fixture child did not become ready")
+
+
+def child_released(marker, timeout=1):
+    deadline = time.monotonic() + timeout
+    with marker.open("r+") as stream:
+        while True:
+            try:
+                fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                return True
+            except BlockingIOError:
+                if time.monotonic() >= deadline:
+                    return False
+                time.sleep(0.01)
+
+
+def reap_fixture(marker):
+    if marker.exists() and marker.stat().st_size and not child_released(marker, timeout=0):
+        # The unique file lock proves the original fixture process still owns this PID.
+        os.kill(int(marker.read_text()), signal.SIGKILL)
+        if not child_released(marker, timeout=5):
+            raise AssertionError("fixture child did not release its process-owned lock")
+
+
+class ScannerAbbaTest(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        self.root = Path(self.temp.name)
+        self.binary = Path(sys.executable).resolve()
+        self.adapter = Path(__file__).resolve()
+        self.manifest = {
+            "schema": 1, "evidence": "synthetic", "rounds": 3, "duration_seconds": 1, "min_free_bytes": 1,
+            "fixed": {"config_sha256": "1" * 64, "dataset_sha256": "2" * 64,
+                      "release_flags": "--release", "durability": "drive-sync=on",
+                      "disk_type": "synthetic", "cache_state": "cold", "load_command": "fake",
+                      "topology": "EC8+4", "offered_load_ops": 100, "resource_isolation": "synthetic"},
+            "oracles": {s: {"objects": 10, "versions": 20, "bytes": 30, "sha256": "3" * 64} for s in harness.SCENARIOS},
+            "expected_healed_objects": {s: 10 for s in harness.SCENARIOS},
+        }
+        build = {"binary": str(self.binary), "sha256": harness.digest(self.binary), "revision": "a" * 40}
+        self.manifest.update(baseline=build.copy(), candidate=build.copy())
+
+    def run_harness(self, fault=""):
+        with patch.dict(os.environ, {"SCANNER_ABBA_TEST_FAULT": fault}), contextlib.redirect_stdout(io.StringIO()):
+            return harness.run(copy.deepcopy(self.manifest), self.adapter, self.root / "out", self.root / "data")
+
+    def test_adapter_timeout_reaps_group_after_parent_exits_on_term(self):
+        request = self.root / "request.json"
+        harness.write_json(request, {})
+        marker = self.root / "stubborn.pid"
+        try:
+            with patch.dict(os.environ, {"SCANNER_ABBA_TEST_FAULT": "stubborn-child"}):
+                with self.assertRaises(subprocess.TimeoutExpired):
+                    harness.invoke(self.adapter, "measure", request, 3)
+            wait_for_marker(marker)
+            self.assertTrue(child_released(marker), "TERM-exited parent left its TERM-ignoring child alive")
+        finally:
+            reap_fixture(marker)
+
+    def test_collector_failure_reaps_group_after_parent_exits_on_term(self):
+        request = self.root / "request.json"
+        harness.write_json(request, {})
+        marker = self.root / "stubborn.pid"
+        collector = self.root / "run_scanner_validation_harness.sh"
+        command = [sys.executable, str(self.adapter), "measure", str(request), str(self.root / "unused.json")]
+        collector.write_text("#!/usr/bin/env bash\nexec " + shlex.join(command) + "\n")
+
+        def failed_measure(*_):
+            wait_for_marker(marker)
+            raise ValueError("injected measurement failure")
+
+        try:
+            with patch.dict(os.environ, {"SCANNER_ABBA_TEST_FAULT": "stubborn-child"}), \
+                 patch.object(harness, "__file__", str(self.root / "scanner_abba.py")), \
+                 patch.object(harness, "invoke", side_effect=failed_measure):
+                with self.assertRaisesRegex(ValueError, "injected measurement failure"):
+                    harness.collect_live({"collector": {"alias": "fixture", "endpoint": "fixture", "metrics_endpoints": "fixture"}},
+                                         {"duration_seconds": 900}, request, self.adapter)
+            self.assertTrue(child_released(marker), "collector parent exit did not end its telemetry child")
+        finally:
+            reap_fixture(marker)
+
+    def test_successful_prepare_keeps_service_alive(self):
+        request = self.root / "request.json"
+        harness.write_json(request, {})
+        marker = self.root / "stubborn.pid"
+        try:
+            with patch.dict(os.environ, {"SCANNER_ABBA_TEST_FAULT": "stubborn-child"}):
+                self.assertEqual(harness.invoke(self.adapter, "prepare", request, 5), {"ready": True})
+                self.assertFalse(child_released(marker, timeout=0), "successful prepare must preserve its service")
+                self.assertEqual(harness.invoke(self.adapter, "stop", request, 5), {"stopped": True})
+            self.assertTrue(child_released(marker), "adapter stop must release its service")
+        finally:
+            reap_fixture(marker)
+
+    def test_reaped_owner_never_signals_a_reused_process_group(self):
+        with (self.root / "owner.log").open("wb") as log:
+            owner = harness.OwnedCommand([sys.executable, "-c", "pass"], log)
+            self.assertEqual(owner.wait(5), 0)
+            self.assertEqual(owner.finish(), 0)
+            with patch.object(harness.os, "killpg", side_effect=AssertionError("released PGID must not be signalled")):
+                self.assertEqual(owner.finish(terminate=True), 0)
+
+    def test_cleanup_interruption_still_kills_group_and_reaps_leader(self):
+        request = self.root / "request.json"
+        harness.write_json(request, {})
+        marker = self.root / "stubborn.pid"
+        original_sleep = time.sleep
+        interrupted = False
+
+        def interrupt_once(delay):
+            nonlocal interrupted
+            if not interrupted:
+                interrupted = True
+                raise KeyboardInterrupt
+            original_sleep(delay)
+
+        with (self.root / "interrupted.log").open("wb") as log:
+            with patch.dict(os.environ, {"SCANNER_ABBA_TEST_FAULT": "stubborn-child"}):
+                owner = harness.OwnedCommand([str(self.adapter), "measure", str(request), str(self.root / "unused.json")], log)
+            try:
+                wait_for_marker(marker)
+                with patch.object(harness.time, "sleep", side_effect=interrupt_once):
+                    with self.assertRaises(KeyboardInterrupt):
+                        owner.finish(terminate=True)
+                self.assertTrue(child_released(marker), "cleanup cancellation left its child alive")
+                self.assertIsNotNone(owner.process.returncode, "cleanup cancellation must reap its leader")
+            finally:
+                reap_fixture(marker)
+                owner.process.wait(timeout=5)
+
+    def test_constructor_failure_after_gate_release_kills_group(self):
+        request = self.root / "request.json"
+        harness.write_json(request, {})
+        marker = self.root / "stubborn.pid"
+        original_write = os.write
+
+        def release_then_fail(fd, data):
+            original_write(fd, data)
+            wait_for_marker(marker)
+            raise OSError("injected failure after gate release")
+
+        try:
+            with (self.root / "construction.log").open("wb") as log, \
+                 patch.dict(os.environ, {"SCANNER_ABBA_TEST_FAULT": "stubborn-child"}), \
+                 patch.object(harness.os, "write", side_effect=release_then_fail):
+                with self.assertRaisesRegex(OSError, "injected failure after gate release"):
+                    harness.OwnedCommand([str(self.adapter), "measure", str(request), str(self.root / "unused.json")], log)
+            self.assertTrue(child_released(marker), "initialization failure left its child alive")
+        finally:
+            reap_fixture(marker)
+
+    def test_complete_synthetic_matrix_is_not_performance_evidence(self):
+        self.assertEqual(self.run_harness(), 0)
+        report = harness.read_json(self.root / "out/report.json")
+        self.assertEqual((report["status"], report["performance"], report["cells"]), ("synthetic_validated", "pending", 120))
+        requests = [harness.read_json(path) for path in (self.root / "out").glob("*/request.json")]
+        self.assertEqual(len({r["data_dir"] for r in requests}), 120)
+        for scenario in harness.SCENARIOS:
+            for comparison in ("build", "background"):
+                for round_id in (1, 2, 3):
+                    legs = [r for r in requests if (r["scenario"], r["comparison"], r["round"]) == (scenario, comparison, round_id)]
+                    self.assertEqual({r["leg"] for r in legs}, set(harness.LEGS))
+        self.assertTrue(all(c["p2_max_work_multiple"] == 1.2 for c in report["comparisons"]))
+
+    def test_fail_closed_adapter_and_data_errors(self):
+        for fault in ("measure-exit", "oracle-exit", "missing-oracle", "oracle-mismatch", "zero-samples",
+                      "zero-requests", "request-errors", "load-drift", "missing-metric", "incomplete-repair"):
+            with self.subTest(fault=fault), tempfile.TemporaryDirectory() as directory:
+                self.root = Path(directory)
+                with self.assertRaises((ValueError, OSError, subprocess.SubprocessError)):
+                    self.run_harness(fault)
+                report = harness.read_json(self.root / "out/report.json")
+                self.assertEqual(report["status"], "failed")
+                self.assertTrue(list((self.root / "out").glob("*/stop.json")))
+
+    def test_noise_is_inconclusive_and_nonzero(self):
+        with patch.object(harness, "SCENARIOS", ("cold-hot",)):
+            self.assertEqual(self.run_harness("noise"), 3)
+        self.assertEqual(harness.read_json(self.root / "out/report.json")["status"], "inconclusive")
+
+    def test_missing_first_publication_is_inconclusive(self):
+        with patch.object(harness, "SCENARIOS", ("cold-hot",)):
+            self.assertEqual(self.run_harness("no-publication"), 3)
+
+    def test_performance_regressions_fail(self):
+        for fault in ("p1-regression", "p2-regression", "latency-regression"):
+            with self.subTest(fault=fault), tempfile.TemporaryDirectory() as directory:
+                self.root = Path(directory)
+                with patch.object(harness, "SCENARIOS", ("cold-hot",)):
+                    self.assertEqual(self.run_harness(fault), 1)
+
+    def test_exact_threshold_boundaries_pass(self):
+        with patch.object(harness, "SCENARIOS", ("cold-hot",)):
+            self.assertEqual(self.run_harness("exact-thresholds"), 0)
+
+    def test_just_over_threshold_fails(self):
+        with patch.object(harness, "SCENARIOS", ("cold-hot",)):
+            self.assertEqual(self.run_harness("just-over-threshold"), 1)
+
+    def test_p1_fractional_boundary(self):
+        for fault, expected in (("p1-exact-fraction", 0), ("p1-over-fraction", 1)):
+            with self.subTest(fault=fault), tempfile.TemporaryDirectory() as directory:
+                self.root = Path(directory)
+                with patch.object(harness, "SCENARIOS", ("cold-hot",)):
+                    self.assertEqual(self.run_harness(fault), expected)
+
+    def test_manifest_rejects_missing_build_or_oracle(self):
+        for section, key in (("baseline", "binary"), ("oracles", "cold-hot")):
+            manifest = copy.deepcopy(self.manifest)
+            del manifest[section][key]
+            with self.subTest(section=section), self.assertRaises((ValueError, KeyError)):
+                harness.validate_manifest(manifest)
+
+    def test_short_measured_window_and_fewer_rounds_rejected(self):
+        self.manifest["evidence"] = "measured"
+        with self.assertRaisesRegex(ValueError, "duration_seconds"):
+            harness.validate_manifest(self.manifest)
+        self.manifest["duration_seconds"] = 900
+        self.manifest["rounds"] = 2
+        with self.assertRaisesRegex(ValueError, "rounds"):
+            harness.validate_manifest(self.manifest)
+
+    def test_existing_data_preserved(self):
+        (self.root / "data").mkdir()
+        marker = self.root / "data/keep"
+        marker.write_text("existing")
+        with self.assertRaisesRegex(ValueError, "preserved"):
+            self.run_harness()
+        self.assertEqual(marker.read_text(), "existing")
+
+    def test_invalid_or_live_write_window_does_not_claim_p2(self):
+        self.assertIsNone(harness.convergence({"convergence": {"writes_stopped": False}}))
+        with self.assertRaises(ValueError):
+            harness.convergence({"convergence": {"writes_stopped": True, "last_mutation_observed": True,
+                                                 "first_complete_publication": True}})
+
+    def test_nan_and_oversized_samples_rejected(self):
+        with self.assertRaises(ValueError):
+            harness.number(float("nan"), "latency")
+        path = self.root / "oversized.json"
+        path.write_bytes(b" " * (harness.MAX_JSON_BYTES + 1))
+        with self.assertRaisesRegex(ValueError, "oversized"):
+            harness.read_json(path)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 3 and sys.argv[1] == "--stubborn-worker":
+        signal.signal(signal.SIGTERM, signal.SIG_IGN)
+        with Path(sys.argv[2]).open("w+") as marker:
+            fcntl.flock(marker, fcntl.LOCK_EX)
+            marker.write(str(os.getpid()))
+            marker.flush()
+            while True:
+                time.sleep(1)
+    if len(sys.argv) == 4 and sys.argv[1] in ("prepare", "measure", "oracle", "stop"):
+        sys.exit(fake_adapter())
+    unittest.main()

scripts/test_scanner_validation_harness.sh

@@ -312,3 +312,5 @@ if PATH="$BIN_DIR:$PATH" "$SCRIPT" --secret-key rustfsadmin >"$secret_arg_log" 2
 fi
 
 grep -q -- 'unknown arg: --secret-key' "$secret_arg_log"
+
+"$ROOT_DIR/scripts/python_bin.sh" "$ROOT_DIR/scripts/test_scanner_abba.py"

scripts/test_security_workflow.py

@@ -355,8 +355,6 @@ fi
                 self.assertFalse(any(line.strip().startswith("continue-on-error:") for line in self.steps[handoff]))
                 self.assertIn("        if: always()", self.steps["Cleanup environment (after)"])
                 self.assertLess(list(self.steps).index("Cleanup environment (after)"), list(self.steps).index(handoff))
-                initialized = self.run_step("Initialize functional evidence")
-                self.assertEqual(initialized.returncode, 0, initialized.stderr)
                 suite = self.directory / "auto-testing/rustfs-replication-test.sh"
                 suite.write_text('#!/bin/sh\nprintf "suite failed\\n" >> "$EXECUTED"\nexit 17\n')
                 failed = self.run_step("Run replication suite")