Compare commits

..

40 Commits

Author SHA1 Message Date
Hauser Zhi e296adef35 Merge branch 'main' into update_flake_lock_action 2026-11-22 14:44:52 +08:00
Hauser Zhi 496a34a6a7 chore(deps): drop hotpath shear ignore and refresh workspace deps (#9557)
* chore(shear): stop ignoring hotpath and clear shear findings

Remove hotpath from cargo-shear ignored so feature-only usage is reported,
drop unused deps found by shear --fix, delete empty access_owned stubs, and
suppress false-positive unlinked paths for #[path] test modules.

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

* chore(deps): refresh workspace deps and bump faster-hex to 2.0

Run cargo update and cargo upgrade for compatible requirements, including
faster-hex 1.0.0 to 2.0.0. Existing hex_string/hex_decode call sites remain
compatible.

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

* fix(zstd): import seekable directly for security tests

Use zstd_safe::seekable in the security test and document why the
seekable dev-dependency stays: it enables the feature and must remain
visible to cargo-shear as a real usage.

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

* fix(admin): avoid private-bounds on S3Router test helper

Move call_legacy to a free function so the pub(crate) OwnedOperation
bound is not attached to a public inherent impl.

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

* chore(deps): drop unused hotpath and demote rio md-5 to dev-deps

Remove hotpath from crates that only feature-forward it with no source
usage, keep rustfs-* hotpath feature links, make rio's hotpath optional
for its cfg-gated measure_block!, and move rio md-5 to dev-dependencies.

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

* chore(deps): refresh lockfile and bump arrow/jiff requirements

Run cargo update, cargo upgrade, and cargo upgrade --incompatible.
Bump arrow/parquet to 60.2.0 and jiff to 1.0.2.

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

* fix(scanner): run service_cohort tests on a larger stack

Linux libtest defaults to a 2 MiB test-thread stack; two-pool EC fixtures
overflow it and abort. Run each service_cohort case on a dedicated 32 MiB
thread, matching scoped_entry_fallback.

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

* chore(deps): upgrade russh-sftp to 4.0 and refresh lockfile

Run cargo update, cargo upgrade, and cargo upgrade --incompatible.
Bump russh-sftp 3 to 4 (opaque SftpHandle wire type), plus lapin,
hashbrown, and russh. Adapt the SFTP Handler and tests to SftpHandle.

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

---------

Co-authored-by: qunjiazhu <qunjiazhu@gmail.com>
Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
Co-authored-by: RustFS <hello@rustfs.com>
2026-11-22 14:36:14 +08:00
overtrue 7c9ebadffe test(multipart): build the out-of-order complete envelope on the owned request
The out-of-order parts still go through the adapter's tag walk and still
fail as InvalidPartOrder.
2026-11-22 14:06:06 +08:00
overtrue e376e7d774 test(multipart): build the duplicate-part complete envelope on the owned request
The duplicate part numbers still go through the adapter's tag walk and still
must not fail as InvalidPartOrder.
2026-11-22 13:37:27 +08:00
overtrue d211df88d5 test(multipart): build the missing-parts-list complete envelope on the owned request
The empty CompleteMultipartUpload element still follows the adapter's Some branch
and checks InvalidRequest.
2026-11-22 13:08:17 +08:00
houseme af0a20527d chore(deps): update flake.lock
Flake lock file updates:

• Updated input 'nixpkgs':
    'github:NixOS/nixpkgs/2074cc6' (2026-11-12)
  → 'github:NixOS/nixpkgs/93a9ed0' (2026-11-21)
• Updated input 'rust-overlay':
    'github:oxalica/rust-overlay/5b87ee0' (2026-11-14)
  → 'github:oxalica/rust-overlay/52db205' (2026-11-21)
2026-11-22 05:07:43 +00:00
overtrue 21caf8bf34 test(multipart): build the missing-parts complete envelope on the owned request
The fixture has no multipart upload, so it follows the adapter's None branch
and still checks InvalidPart.
2026-11-22 12:32:41 +08:00
overtrue d3eaaa21a6 test(multipart): build the range copy envelope on the owned request
The range path still maps the copy DTO the same way as the adapter and checks
EntityTooLarge, permit release, and the copied bytes.
2026-11-22 11:57:28 +08:00
overtrue ad457a2d1c test(multipart): build the cancelled copy envelope on the owned request
The cancellation path still maps the copy DTO the same way as the adapter
and still panics if the copy finishes before cancellation.
2026-11-22 11:25:09 +08:00
overtrue fa3ea5b4e5 test(multipart): build the deleted-source copy envelope on the owned request
The deleted-source rejection still maps the copy DTO the same way as the adapter
and checks NoSuchKey or MethodNotAllowed on the owned error.
2026-11-22 10:50:06 +08:00
overtrue f3396952b6 test(multipart): build the saturated copy envelope on the owned request
The occupied UploadPart pool still maps the copy DTO the same way as the adapter
and checks SlowDown on the owned error.
2026-11-22 10:23:10 +08:00
overtrue 8736b49d08 test(multipart): build the uninitialized copy envelope on the owned request
The uninitialized-store rejection still maps the copy DTO the same way as the adapter
and checks InternalError on the owned error.
2026-11-22 09:47:55 +08:00
overtrue eec468e488 test(multipart): build the admission upload envelope on the owned request. 2026-11-22 09:10:40 +08:00
overtrue f2af45ee68 test(multipart): build the invalid-storage-class create envelope on the owned request
The storage-class rejection still converts the create DTO separately
and checks InvalidStorageClass on the legacy error.
2026-11-22 08:33:58 +08:00
overtrue 25b55febc5 test(multipart): build the part-copy part-number envelope on the owned request
The part-number rejection still maps the copy DTO the same way as the adapter
and checks InvalidArgument with the same message.
2026-11-22 08:05:27 +08:00
overtrue c2e50b3b10 test(multipart): build the part-number upload envelope on the owned request
The part-number rejection still converts the upload DTO separately
and checks InvalidArgument with the same message.
2026-11-22 07:36:17 +08:00
overtrue 6fde592da1 test(multipart): build the oversize upload envelope on the owned request
The declared-size rejection still converts the upload DTO separately
and checks EntityTooLarge without polling the body.
2026-11-22 07:03:43 +08:00
overtrue 98259d7c46 test(multipart): build the missing-body upload envelope on the owned request
The missing-body rejection still converts the upload DTO separately
and checks IncompleteBody on the legacy error.
2026-11-22 06:35:22 +08:00
overtrue b5a35fc2c7 test(multipart): build the baseline create envelope on the owned request
The direct fixture still converts the create DTO separately and checks
the legacy error code and message.
2026-11-22 06:06:39 +08:00
overtrue 11a7572bba test(multipart): build the reserved-key complete envelope on the owned request
The reserved-key complete rejection still converts the DTO through the seam
and checks InvalidArgument on the owned error.
2026-11-22 05:37:37 +08:00
overtrue 4c4dc84671 test(multipart): build the reserved-key create envelope on the owned request
The reserved-key rejection still converts the create DTO separately
and checks InvalidArgument on the legacy error.
2026-11-22 05:06:23 +08:00
overtrue 52986eefd5 test(bucket): build the list-v1 envelope on the owned request
The XML-safe marker listing still converts ListObjectsInput separately
and keeps the same GET envelope with an empty head.
2026-11-22 04:25:57 +08:00
overtrue 7a5ffcfee7 test(multipart): build the complete listing envelopes on the owned request
The version and V1 listing checks build method-only envelopes with owned_envelope.
The DTOs still carry the bucket and prefix, and the V2 seam stays.
2026-11-22 03:55:16 +08:00
overtrue 334d615a67 test(bucket): build the encryption lookup envelopes on the owned request
The uninitialized encryption test builds its method-only envelopes with owned_envelope.
The InternalError and MalformedXML assertions stay.
2026-11-22 03:26:14 +08:00
overtrue 0c813e1a9e test(bucket): build the core uninitialized envelopes on the owned request
The no-req_info envelope is built with owned_envelope.
The arm that carries req_info still goes through from_s3s.
2026-11-22 02:50:05 +08:00
overtrue 0de0b85374 test(lifecycle): build the object-lock envelope on the owned request
The object-lock replication test builds its method-only envelope with from_parts.
The existing ignore attribute and the replication-count assertions stay.
2026-11-22 02:23:15 +08:00
overtrue 78f78ce5ee test(multipart): build the complete setup envelopes on the owned request
The versioning and encryption setup calls build method-only envelopes with owned_envelope.
The requests that carry a body still use build_request.
2026-11-22 01:54:13 +08:00
overtrue 82ad3f0007 test(object): build the attributes lookup envelope on the owned request
The uninitialized-store attributes test builds its method-only envelope with from_parts.
The InternalError assertion is unchanged.
2026-11-22 01:25:00 +08:00
overtrue 82f094f4d5 test(lifecycle): build the suspend-versioning envelope on the owned request
The suspended-bucket helper builds its method-only envelope with from_parts.
The restore call that carries a body still uses build_request.
2026-11-22 00:50:23 +08:00
overtrue e1df1d569b test(multipart): build the upload-part claim envelopes on the owned request
The two method-only upload-part claim tests build their envelopes with owned_envelope.
Every refusal assertion stays.
2026-11-22 00:21:35 +08:00
overtrue 19487a6e34 test(multipart): build the list-parts envelope on the owned request
The list-parts owner lookup builds its method-only envelope with owned_envelope.
The later requests that set a URI still go through from_s3s.
2026-11-21 23:50:20 +08:00
overtrue 6177fc280f test(bucket): build the website lookup envelopes on the owned request 2026-11-21 23:19:40 +08:00
overtrue 14db51bba7 test(bucket): build the logging lookup envelope on the owned request
The missing-bucket logging lookup builds its envelope with owned_envelope.
The NoSuchBucket assertion stays.
2026-11-21 22:48:38 +08:00
overtrue 353de54fcc test(bucket): build the missing-lifecycle envelope on the owned request 2026-11-21 22:14:58 +08:00
overtrue 6a4f93bbaf test(bucket): build the tagging envelope on the owned request 2026-11-21 21:40:20 +08:00
overtrue 74fab85ba0 test(bucket): build the list-buckets envelope on the owned request 2026-11-21 21:00:03 +08:00
overtrue 44db2be5f9 test(multipart): build the abort envelope on the owned request 2026-11-21 20:25:10 +08:00
overtrue 3e41233589 test(multipart): build list envelopes on the owned request 2026-11-21 19:50:10 +08:00
overtrue f36a771389 test(bucket): build policy envelopes on the owned request 2026-11-21 19:04:31 +08:00
overtrue 0447e68073 test(bucket): build method-only envelopes on the owned request 2026-11-21 18:31:08 +08:00
100 changed files with 1376 additions and 7574 deletions
Generated
+184 -190
View File
File diff suppressed because it is too large Load Diff
+22 -19
View File
@@ -175,9 +175,9 @@ futures = "0.3.34"
futures-core = "0.3.34"
futures-lite = "2.6.1"
futures-util = "0.3.34"
pollster = "1.0.2"
pollster = "1.0.3"
pulsar = { default-features = false, version = "=6.9.0" }
lapin = { default-features = false, version = "4.12.3" }
lapin = { default-features = false, version = "4.13.0" }
hyper = { version = "1.12.0" }
h2 = { version = "0.4.20" }
hyper-rustls = { default-features = false, version = "0.27.10" }
@@ -216,7 +216,7 @@ csv-core = "0.1.13"
bytesize = "2.7.0"
byteorder = "1.5.0"
flatbuffers = "25.12.19"
form_urlencoded = "1.2.2"
form_urlencoded = "1.2.3"
prost = "0.14.6"
quick-xml = "0.42.0"
rmp = { version = "0.8.15" }
@@ -258,7 +258,7 @@ proptest = "1"
# Time and Date
chrono = { version = "0.4.45" }
humantime = "2.4.0"
jiff = { version = "1.0.1" }
jiff = { version = "1.0.2" }
time = { version = "0.3.55" }
# Database
@@ -278,15 +278,15 @@ atomic_enum = "0.3.0"
aws-config = { version = "1.13.3" }
aws-credential-types = { version = "1.3.1" }
aws-sdk-kms = { default-features = false, version = "1.133.0" }
aws-sdk-s3 = { default-features = false, version = "1.160.0" }
aws-sdk-sts = { default-features = false, version = "1.127.0" }
aws-sdk-s3 = { default-features = false, version = "1.161.0" }
aws-sdk-sts = { default-features = false, version = "1.128.0" }
aws-smithy-async = { version = "1.3.1" }
aws-smithy-http-client = { default-features = false, version = "1.5.3" }
aws-smithy-runtime-api = { version = "1.22.0" }
aws-smithy-types = { version = "1.9.4" }
base64-simd = "0.8.0"
brotli = "9.1.3"
clap = { version = "4.6.8" }
clap = { version = "4.6.9" }
const-str = { version = "1.1.0" }
convert_case = "0.12.0"
criterion = { version = "0.8" }
@@ -298,12 +298,12 @@ datafusion = { default-features = false, version = "55.3.0" }
derive_builder = "0.20.2"
ed25519-dalek = "3.0.0"
enumset = "1.1.15"
faster-hex = "1.0.0"
faster-hex = "2.0.0"
flate2 = "1.1.11"
glob = "0.3.4"
google-cloud-storage = "1.22.0"
google-cloud-auth = "1.19.0"
hashbrown = { version = "0.17.1" }
hashbrown = { version = "0.17.2" }
# Base32 for RFC 6238 TOTP shared secrets (RFC 4648 unpadded, the alphabet
# every authenticator app expects). Already in the graph transitively.
data-encoding = "2.11.1"
@@ -337,7 +337,7 @@ percent-encoding = "2.3.2"
# CLI needs its own QR encoder. No default features: the image/render backends
# pull in an image stack this only needs SVG and text output from.
qrcode-rs = { version = "2.2.0", default-features = false, features = ["std", "svg"] }
pin-project-lite = "0.2.17"
pin-project-lite = "0.2.18"
pretty_assertions = "1.4.1"
rand = { version = "0.10.4" }
ratelimit = "2.0.0"
@@ -360,7 +360,7 @@ legacy-s3s = { package = "s3s", git = "https://github.com/s3s-project/s3s", rev
serial_test = "4.0.1"
shadow-rs = { default-features = false, version = "2.0.0" }
siphasher = "1.0.4"
smallvec = { version = "1.16.5" }
smallvec = { version = "1.16.6" }
compact_str = "0.10.0"
snap = "1.1.2"
starshard = { version = "2.4.1" }
@@ -378,23 +378,23 @@ tracing-error = "0.2.1"
tracing-opentelemetry = { version = "0.34.0" }
tracing-subscriber = { version = "0.3.23" }
transform-stream = "0.3.1"
url = "2.5.8"
url = "2.5.9"
urlencoding = "2.1.3"
uuid = { version = "1.29.3" }
vaultrs = { version = "0.8.0" }
tar = "0.4.46"
walkdir = "2.5.0"
walkdir = "2.5.1"
winapi-util = "0.1.11"
windows = { version = "0.62.2" }
windows-sys = "0.61.2"
xxhash-rust = { version = "0.8.21" }
zip = "9.7.0"
zip = "9.8.1"
zstd = "0.14.4"
# Observability and Metrics
metrics = "0.24.6"
metrics-util = "0.20"
dial9 = { version = "0.5.8", default-features = false }
dial9 = { version = "0.5.9", default-features = false }
opentelemetry = { version = "0.33.1" }
opentelemetry-appender-tracing = { version = "0.33.1" }
opentelemetry-otlp = { version = "0.33.1" }
@@ -405,12 +405,12 @@ opentelemetry-stdout = { version = "0.33.1" }
pyroscope = { version = "2.1.5" }
# FTP and SFTP
libunftp = { version = "0.25.0" }
libunftp = { version = "0.25.1" }
unftp-core = "0.1.1"
suppaftp = { version = "13.0.0" }
rcgen = { version = "0.14.10", default-features = false, features = ["aws_lc_rs", "crypto", "pem"] }
russh = { version = "0.65.2" }
russh-sftp = "3.0.1"
russh = { version = "0.65.4" }
russh-sftp = "4.0.0"
# WebDAV
dav-server = "0.12.0"
@@ -423,7 +423,10 @@ hotpath = { version = "0.32.1", default-features = false }
insta = { version = "1.49" }
[workspace.metadata.cargo-shear]
ignored = ["hotpath", "rustfs"]
# The `#[path]` test modules under `rustfs/src/server/http/tests/` are linked by
# rustc (including the `http.rs` + `http/` sibling-directory rule), but cargo-shear
# resolves those nested `#[path]` attributes against the wrong base directory.
ignored-paths = ["rustfs/src/server/http/tests/**/*.rs"]
[profile.dev]
# Full debuginfo roughly doubles compile+link time and produces multi-GB
+3 -4
View File
@@ -15,12 +15,11 @@ workspace = true
[features]
default = []
hotpath = ["hotpath/hotpath", "hotpath/tokio", "rustfs-io-core/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-io-core/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-io-core/hotpath-cpu"]
hotpath = ["rustfs-io-core/hotpath"]
hotpath-alloc = ["hotpath", "rustfs-io-core/hotpath-alloc"]
hotpath-cpu = ["hotpath", "rustfs-io-core/hotpath-cpu"]
[dependencies]
hotpath.workspace = true
# Internal crates
rustfs-io-core = { workspace = true }
serde = { workspace = true, features = ["derive"] }
+3 -72
View File
@@ -1235,66 +1235,23 @@ impl Serialize for DataUsageEntry {
where
S: serde::Serializer,
{
self.serialize_fields(serializer, &self.children, &self.replication_stats, &self.all_tier_stats)
}
}
struct OrderedUsageEntry<'a>(&'a DataUsageEntry);
impl Serialize for OrderedUsageEntry<'_> {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
let mut children: Vec<_> = self.0.children.iter().collect();
children.sort_unstable();
// MessagePack decoders accept struct fields as positional sequences.
// Include the nested target and tier maps in stable order as well.
let replication = self.0.replication_stats.as_ref().map(|stats| {
let ReplicationAllStats {
targets,
replica_size,
replica_count,
} = stats;
let targets: std::collections::BTreeMap<_, _> = targets.iter().collect();
(targets, replica_size, replica_count)
});
let tiers = self.0.all_tier_stats.as_ref().map(|stats| {
let AllTierStats { tiers } = stats;
let tiers: std::collections::BTreeMap<_, _> = tiers.iter().collect();
(tiers,)
});
self.0.serialize_fields(serializer, &children, &replication, &tiers)
}
}
impl DataUsageEntry {
/// Stable MessagePack encoding for independently reusable scanner checkpoint pages.
pub fn ordered_encoding(&self) -> impl Serialize + '_ {
OrderedUsageEntry(self)
}
fn serialize_fields<S: serde::Serializer, C: Serialize, R: Serialize, T: Serialize>(
&self,
serializer: S,
children: &C,
replication: &R,
tiers: &T,
) -> Result<S::Ok, S::Error> {
// Keep entries map-encoded so older readers can ignore fields appended
// by newer scanner versions during rolling upgrades. The derived
// (array) encoding made any appended field a decode error for them.
let mut state = serializer.serialize_map(Some(
11 + usize::from(self.unknown_tier_stats.is_some()) + usize::from(self.tier_accounting_proof.is_some()),
))?;
state.serialize_entry("children", children)?;
state.serialize_entry("children", &self.children)?;
state.serialize_entry("size", &self.size)?;
state.serialize_entry("objects", &self.objects)?;
state.serialize_entry("versions", &self.versions)?;
state.serialize_entry("delete_markers", &self.delete_markers)?;
state.serialize_entry("obj_sizes", &self.obj_sizes)?;
state.serialize_entry("obj_versions", &self.obj_versions)?;
state.serialize_entry("replication_stats", replication)?;
state.serialize_entry("replication_stats", &self.replication_stats)?;
state.serialize_entry("compacted", &self.compacted)?;
state.serialize_entry("failed_objects", &self.failed_objects)?;
state.serialize_entry("all_tier_stats", tiers)?;
state.serialize_entry("all_tier_stats", &self.all_tier_stats)?;
// Keep the legacy no-unknown shape byte-for-byte stable. Once unknown
// accounting exists, append its map field before the optional proof.
if let Some(unknown_tier_stats) = self.unknown_tier_stats.as_ref() {
@@ -2577,32 +2534,6 @@ mod tests {
entry
}
#[test]
fn ordered_checkpoint_entry_round_trips_and_stays_identical_after_reload() {
let mut entry = DataUsageEntry::default();
let mut replication = ReplicationAllStats {
replica_size: 998,
replica_count: 3,
..Default::default()
};
let mut tiers = AllTierStats::default();
for index in 1..=32 {
let key = format!("source-{index}");
entry.children.insert(key.clone());
replication.targets.insert(key.clone(), ReplicationTargetUsage::default());
tiers.tiers.insert(key, TierStats::default());
}
entry.replication_stats = Some(replication);
entry.all_tier_stats = Some(tiers);
let bytes = rmp_serde::to_vec(&entry.ordered_encoding()).expect("encode ordered checkpoint");
let reloaded: DataUsageEntry = rmp_serde::from_slice(&bytes).expect("read with the existing codec");
assert_eq!(reloaded.children, entry.children);
let replicas = reloaded.replication_stats.as_ref().expect("replication stats");
assert_eq!((replicas.targets.len(), replicas.replica_size, replicas.replica_count), (32, 998, 3));
assert_eq!(reloaded.all_tier_stats.as_ref().expect("tier stats").tiers.len(), 32);
assert_eq!(rmp_serde::to_vec(&reloaded.ordered_encoding()).expect("encode reloaded entry"), bytes);
}
#[test]
fn tier_stats_survive_entry_merge() {
let mut left = tier_entry(
-3
View File
@@ -105,9 +105,6 @@ mod replication_target_matrix_test;
#[cfg(test)]
mod data_usage_test;
#[cfg(test)]
mod scanner_wide_directory_test;
// KMS-specific test modules
#[cfg(test)]
mod kms;
@@ -1,208 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use std::collections::BTreeMap;
use std::path::Path;
use std::time::{Duration, SystemTime};
use aws_sdk_s3::{Client, primitives::ByteStream};
use futures::{StreamExt, TryStreamExt, stream};
use rustfs_data_usage::{BucketUsageValueState, DataUsageInfo};
use serde::{Deserialize, de::DeserializeOwned};
use tokio::time::{Instant, sleep, timeout};
use crate::common::{RustFSTestEnvironment, signed_request};
use crate::storage_api::scanner_peer_bucket::{BUCKET_META_PREFIX, RUSTFS_META_BUCKET};
type TestResult<T = ()> = Result<T, Box<dyn std::error::Error + Send + Sync>>;
const BUCKET: &str = "wide-directory-usage";
const WIDTH: usize = 512;
// The per-disk token bucket allows an initial burst of one second. Even the
// first pass can read at most (1 + 3) * 96 = 384 of these 512 root entries.
const SCAN_ENV: &[(&str, &str)] = &[
("RUST_LOG", "warn,rustfs::scanner::io=debug,rustfs::scanner::data_usage=debug"),
("RUSTFS_SCANNER_ENABLED", "true"),
("RUSTFS_SCANNER_START_DELAY_SECS", "0"),
("RUSTFS_SCANNER_CYCLE", "1"),
("RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS", "3"),
("RUSTFS_SCANNER_SPEED", "fastest"),
("RUSTFS_SCANNER_DISK_IO_BUDGET_IOPS", "96"),
("RUSTFS_SCANNER_DISK_IO_BUDGET_BYTES_PER_SEC", "off"),
];
#[derive(Debug, Deserialize)]
struct Status {
metrics: Metrics,
disk_io_budget: Vec<DiskBudget>,
}
#[derive(Debug, Deserialize)]
struct Metrics {
current_cycle_active: bool,
active_paths: Vec<String>,
cycle_max_duration_seconds: f64,
partial_cycles_runtime: u64,
}
#[derive(Debug, Deserialize)]
struct DiskBudget {
iops: Option<u64>,
}
async fn admin<T: DeserializeOwned>(env: &RustFSTestEnvironment, resource: &str) -> TestResult<T> {
let url = format!("{}/rustfs/admin/v3/{resource}", env.url);
let response = signed_request(http::Method::GET, &url, &env.access_key, &env.secret_key, None, None).await?;
Ok(response.error_for_status()?.json().await?)
}
async fn inventory(client: &Client) -> TestResult<BTreeMap<String, u64>> {
let mut pages = client.list_objects_v2().bucket(BUCKET).max_keys(37).into_paginator().send();
let mut sizes = BTreeMap::new();
while let Some(page) = pages.next().await {
for object in page?.contents() {
let key = object.key().ok_or("S3 inventory omitted object key")?;
let size = u64::try_from(object.size().ok_or("S3 inventory omitted object size")?)?;
assert!(sizes.insert(key.to_owned(), size).is_none(), "duplicate inventory key {key}");
}
}
Ok(sizes)
}
async fn scan_status(env: &RustFSTestEnvironment) -> TestResult<Status> {
let status: Status = admin(env, "scanner/status").await?;
assert_eq!(status.metrics.cycle_max_duration_seconds, 3.0, "effective cycle budget");
assert!(status.disk_io_budget.iter().all(|disk| disk.iops == Some(96)), "effective disk budget");
Ok(status)
}
#[tokio::test(flavor = "multi_thread")]
async fn certifies_wide_directory_after_mid_scan_process_restart() -> TestResult {
let mut env = RustFSTestEnvironment::new().await?;
let temporary_log = tempfile::NamedTempFile::new()?;
let server_log = env
.capture_log_path
.get_or_insert_with(|| temporary_log.path().display().to_string())
.clone();
let bucket_metadata = Path::new(&env.temp_dir)
.join(RUSTFS_META_BUCKET)
.join(BUCKET_META_PREFIX)
.join(BUCKET);
// Seed a cold bucket without allowing any earlier, larger-budget sweep to count it.
env.start_rustfs_server_without_cleanup_with_env(&[("RUSTFS_SCANNER_ENABLED", "false")])
.await?;
let client = env.create_s3_client();
client.create_bucket().bucket(BUCKET).send().await?;
stream::iter(0..WIDTH)
.map(Ok)
.try_for_each_concurrent(12, |i| {
let client = &client;
async move {
client
.put_object()
.bucket(BUCKET)
.key(format!("object-{i:064x}"))
.body(ByteStream::from(vec![42; 1 + i % 67]))
.send()
.await
.map(|_| ())
}
})
.await?;
let expected = inventory(&client).await?;
assert_eq!(expected.len(), WIDTH);
env.restart_server_preserving_data(vec![], SCAN_ENV).await?;
let first_pid = env.process.as_ref().ok_or("missing scanner process")?.id();
timeout(Duration::from_secs(60), async {
loop {
let status = scan_status(&env).await?;
if status.metrics.partial_cycles_runtime >= 1
&& bucket_metadata.join(".usage-cache.bin").join("xl.meta").is_file()
&& bucket_metadata.join(".usage-cache.bin.pages").is_dir()
&& status.metrics.current_cycle_active
&& status
.metrics
.active_paths
.iter()
.any(|path| path.split('/').any(|part| part == BUCKET))
{
let log = tokio::fs::read_to_string(&server_log).await?;
if !log
.lines()
.any(|line| line.contains("partial_saved_not_published") && line.contains(BUCKET))
{
sleep(Duration::from_millis(200)).await;
continue;
}
assert!(!status.disk_io_budget.is_empty(), "scanner never admitted disk I/O");
break Ok::<_, Box<dyn std::error::Error + Send + Sync>>(());
}
sleep(Duration::from_millis(200)).await;
}
})
.await
.map_err(|_| "scanner did not re-enter the bucket after exhausting the fixed runtime budget")??;
let partial: DataUsageInfo = admin(&env, "datausageinfo").await?;
assert!(
partial
.buckets_usage
.get(BUCKET)
.is_none_or(|value| value.usage_certification.is_none()),
"the first process certified the bucket before the injected crash"
);
env.stop_server();
// The terminal save has returned and the old process can no longer write.
assert!(
bucket_metadata.join(".usage-cache.bin").join("xl.meta").is_file()
&& bucket_metadata.join(".usage-cache.bin.pages").is_dir(),
"the interrupted process must have committed a paged checkpoint"
);
let restart_log_offset = usize::try_from(tokio::fs::metadata(&server_log).await?.len())?;
let restarted_at = SystemTime::now();
env.start_rustfs_server_without_cleanup_with_env(SCAN_ENV).await?;
let second_pid = env.process.as_ref().ok_or("missing restarted scanner process")?.id();
assert_ne!(first_pid, second_pid);
let deadline = Instant::now() + Duration::from_secs(180);
loop {
let usage: DataUsageInfo = admin(&env, "datausageinfo").await?;
let status = scan_status(&env).await?;
if let Some(bucket) = usage.buckets_usage.get(BUCKET)
&& bucket.usage_value_state == Some(BucketUsageValueState::Certified)
{
let log = tokio::fs::read_to_string(&server_log).await?;
let first_admission = log
.get(restart_log_offset..)
.ok_or("server log truncated across restart")?
.lines()
.filter_map(|line| serde_json::from_str::<serde_json::Value>(line).ok())
.find(|record| record["state"] == "bucket_checkpoint_prepared" && record["bucket"] == BUCKET)
.ok_or("no checkpoint admission in the restarted process")?;
assert_eq!(first_admission["resume_position"], true, "restarted scanner discarded the checkpoint");
assert!(usage.is_complete_bucket_usage_snapshot());
let certificate = bucket
.usage_certification
.ok_or("missing certificate for the measured bucket")?;
assert!(certificate.certified_at >= restarted_at, "stale pre-restart certificate");
assert!(status.metrics.partial_cycles_runtime > 0, "new process must cross a cycle deadline");
assert!(!status.disk_io_budget.is_empty(), "restarted scanner never admitted disk I/O");
assert_eq!(inventory(&client).await?, expected, "durable S3 inventory changed across restart");
let count = u64::try_from(expected.len())?;
let bytes = expected.values().sum::<u64>();
assert_eq!((bucket.objects_count, bucket.size), (count, bytes));
assert_eq!((usage.objects_total_count, usage.objects_total_size), (count, bytes));
eprintln!(
"PIDs {first_pid}/{second_pid}, runtime-limited cycles since restart {}, certificate epoch {} cycle {}, S3 and admin {} objects/{} bytes",
status.metrics.partial_cycles_runtime, certificate.epoch, certificate.cycle, count, bytes
);
return Ok(());
}
assert!(
Instant::now() < deadline,
"no certified bucket after restart: {status:?}, value={:?}",
usage.buckets_usage.get(BUCKET)
);
sleep(Duration::from_millis(500)).await;
}
}
-1
View File
@@ -183,7 +183,6 @@ rmp.workspace = true
rmp-serde.workspace = true
tokio-util = { workspace = true, features = ["io", "compat", "rt"] }
tokio-stream = { workspace = true, features = ["sync"] }
hmac = { workspace = true }
sha2 = { workspace = true }
hex-simd = { workspace = true }
tempfile.workspace = true
@@ -158,7 +158,6 @@ fn to_madmin_scanner_metrics(metrics: rustfs_scanner_metrics::metrics::ScannerMe
last_cycle_lifecycle_transition_actions: metrics.last_cycle_lifecycle_transition_actions,
last_cycle_partial_source: metrics.last_cycle_partial_source,
last_cycle_partial_source_code: metrics.last_cycle_partial_source_code,
last_cycle_partial_stage: metrics.last_cycle_partial_stage,
last_cycle_duration_seconds: metrics.last_cycle_duration_seconds,
last_cycle_objects_scanned: metrics.last_cycle_objects_scanned,
last_cycle_directories_scanned: metrics.last_cycle_directories_scanned,
@@ -686,7 +685,6 @@ mod test {
current_started,
last_cycle_partial_source: "usage".to_string(),
last_cycle_partial_source_code: 1,
last_cycle_partial_stage: Some("object_budget".into()),
cycle_timeout_total: 3,
cycle_recovery_required_total: 2,
cycle_last_progress_age: 17,
@@ -702,7 +700,6 @@ mod test {
assert_eq!(scanner.current_started, current_started);
assert_eq!(scanner.last_cycle_partial_source, "usage");
assert_eq!(scanner.last_cycle_partial_source_code, 1);
assert_eq!(scanner.last_cycle_partial_stage.as_deref(), Some("object_budget"));
assert_eq!(scanner.cycle_timeout_total, 3);
assert_eq!(scanner.cycle_recovery_required_total, 2);
assert_eq!(scanner.cycle_last_progress_age, 17);
+3 -4
View File
@@ -29,12 +29,11 @@ workspace = true
[features]
default = []
hotpath = ["hotpath/hotpath", "hotpath/tokio", "rustfs-io-metrics/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-io-metrics/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-io-metrics/hotpath-cpu"]
hotpath = ["rustfs-io-metrics/hotpath"]
hotpath-alloc = ["hotpath", "rustfs-io-metrics/hotpath-alloc"]
hotpath-cpu = ["hotpath", "rustfs-io-metrics/hotpath-cpu"]
[dependencies]
hotpath.workspace = true
bytes = { workspace = true, features = ["serde"] }
thiserror = { workspace = true }
tokio = { workspace = true, features = ["io-util", "fs", "sync", "rt-multi-thread"] }
-5
View File
@@ -709,8 +709,6 @@ pub struct ScannerMetrics {
pub last_cycle_partial_source: String,
#[serde(rename = "last_cycle_partial_source_code", default)]
pub last_cycle_partial_source_code: u64,
#[serde(rename = "last_cycle_partial_stage", default, skip_serializing_if = "Option::is_none")]
pub last_cycle_partial_stage: Option<String>,
#[serde(rename = "last_cycle_duration_seconds", default)]
pub last_cycle_duration_seconds: f64,
#[serde(rename = "last_cycle_objects_scanned", default)]
@@ -855,7 +853,6 @@ impl ScannerMetrics {
self.last_cycle_partial_reason_code = other.last_cycle_partial_reason_code;
self.last_cycle_partial_source = other.last_cycle_partial_source.clone();
self.last_cycle_partial_source_code = other.last_cycle_partial_source_code;
self.last_cycle_partial_stage.clone_from(&other.last_cycle_partial_stage);
self.last_cycle_duration_seconds = other.last_cycle_duration_seconds;
self.throttle_idle_mode_enabled = other.throttle_idle_mode_enabled;
self.throttle_sleep_factor = other.throttle_sleep_factor;
@@ -2141,7 +2138,6 @@ mod tests {
collected_at: collected_at + SignedDuration::from_secs(1),
last_cycle_partial_source: "lifecycle".to_string(),
last_cycle_partial_source_code: 2,
last_cycle_partial_stage: Some("object_budget".into()),
pacing_pressure: ScannerPacingPressureSnapshot {
primary_pressure: "queued_scans".to_string(),
current_queued_scans: 4,
@@ -2166,7 +2162,6 @@ mod tests {
assert_eq!(scanner.last_cycle_partial_source, "lifecycle");
assert_eq!(scanner.last_cycle_partial_source_code, 2);
assert_eq!(scanner.last_cycle_partial_stage.as_deref(), Some("object_budget"));
assert_eq!(scanner.pacing_pressure.primary_pressure, "queued_scans");
assert_eq!(scanner.pacing_pressure.current_queued_scans, 4);
assert_eq!(scanner.pacing_pressure.current_active_scans, 3);
+13 -7
View File
@@ -410,7 +410,10 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
}
};
let handle = self.allocate_handle(HandleState::Dir(cursor))?;
Ok(Handle { id, handle })
Ok(Handle {
id,
handle: handle.into(),
})
}
/// READDIR body shared with the Handler trait wrapper. Removes the
@@ -666,8 +669,11 @@ mod tests {
assert_eq!(auth.continuation_token, call.continuation_token);
}
assert_eq!(authorized[2].continuation_token.as_ref().map(|value| value.as_str()), Some("next-page"));
let denied =
with_test_auth_override(|_, _, prefix| prefix != Some("private/"), driver.readdir_inner(2, handle.handle)).await;
let denied = with_test_auth_override(
|_, _, prefix| prefix != Some("private/"),
driver.readdir_inner(2, String::from_utf8(handle.handle.into_bytes()).expect("utf8 handle")),
)
.await;
assert!(denied.is_err(), "policy change must deny the next READDIR");
assert_eq!(backend.list_objects_calls().len(), 2, "denied READDIR cannot reach storage");
}
@@ -716,7 +722,7 @@ mod tests {
};
let handle_id = driver.allocate_handle(HandleState::Dir(cursor)).expect("allocate");
let readdir_fut = driver.readdir(1, handle_id.clone());
let readdir_fut = driver.readdir(1, handle_id.clone().into());
with_test_auth_override(|_, _, _| true, async {
tokio::select! {
@@ -758,7 +764,7 @@ mod tests {
// token, no skipped entries).
backend.clear_stall_list_objects_v2();
backend.queue_list_objects_v2_ok_empty();
let result = with_test_auth_override(|_, _, _| true, driver.readdir(2, handle_id)).await;
let result = with_test_auth_override(|_, _, _| true, driver.readdir(2, handle_id.into())).await;
// Empty page returns Eof per readdir's empty-Name-to-Eof translation.
let err = result.expect_err("re-issued READDIR against an empty listing must return Eof, not Ok");
assert!(
@@ -785,7 +791,7 @@ mod tests {
let handle_id = driver.allocate_handle(HandleState::Dir(cursor)).expect("allocate");
let (result, captured) =
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(7, handle_id))).await;
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(7, handle_id.into()))).await;
let err = result.expect_err("exhausted cursor must return Eof");
assert!(matches!(StatusCode::from(err), StatusCode::Eof));
assert!(
@@ -818,7 +824,7 @@ mod tests {
let handle_id = driver.allocate_handle(HandleState::Dir(cursor)).expect("allocate");
let (result, captured) =
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(8, handle_id))).await;
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.readdir(8, handle_id.into()))).await;
let err = result.expect_err("backend error must propagate as Err");
assert!(!matches!(StatusCode::from(err), StatusCode::Eof), "backend error must not be Eof");
assert!(
+30 -17
View File
@@ -33,7 +33,9 @@ use super::write::{build_write_tombstone, fstat_reported_size, rejects_excl_or_t
use crate::common::client::s3::StorageBackend;
use crate::common::gateway::{AuthorizationError, S3Action};
use crate::common::session::SessionContext;
use russh_sftp::protocol::{Attrs, Data, File, FileAttributes, Handle, Name, OpenFlags, Packet, Status, StatusCode, Version};
use russh_sftp::protocol::{
Attrs, Data, File, FileAttributes, Handle, Name, OpenFlags, Packet, SftpHandle, Status, StatusCode, Version,
};
use rustfs_credentials::Credentials;
use rustfs_gateway_types::dto::{AbortMultipartUploadInput, CopyObjectInput, ListObjectsV2Input};
use rustfs_gateway_types::{BucketName, ObjectKey, UploadIdClaim};
@@ -208,6 +210,12 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
}
}
/// russh-sftp 4 hands the Handler opaque `SftpHandle` bytes; the table
/// keys remain the UTF-8 UUID strings this driver mints.
fn handle_table_key(handle: SftpHandle) -> Result<String, SftpError> {
String::from_utf8(handle.into_bytes()).map_err(|_| SftpError::code(StatusCode::Failure))
}
/// Generate a fresh UUID v4 handle, insert the given state into the
/// per-session handle table, and return the handle string. Enforces
/// self.handles_per_session before any UUID generation. Cap-exceeded
@@ -494,8 +502,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
/// Streaming returns (next_part_number - 1) * part_size + buffer
/// length. Failed returns the size recorded at the most recent
/// successful write. An unknown handle returns Failure.
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = %handle), err(Debug))]
async fn fstat(&mut self, id: u32, handle: String) -> Result<Attrs, Self::Error> {
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = ?handle), err(Debug))]
async fn fstat(&mut self, id: u32, handle: SftpHandle) -> Result<Attrs, Self::Error> {
let handle = Self::handle_table_key(handle)?;
self.session_diag.stamp();
let part_size = self.part_size;
let result = self.with_handle_ref(&handle, |state| match state {
@@ -541,8 +550,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
/// exhaustion, so it is normal control flow on this handler. The
/// instrument attribute therefore omits err(Debug) and non-Eof
/// failures are surfaced via the explicit error log below.
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = %handle))]
async fn readdir(&mut self, id: u32, handle: String) -> Result<Name, Self::Error> {
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = ?handle))]
async fn readdir(&mut self, id: u32, handle: SftpHandle) -> Result<Name, Self::Error> {
let handle = Self::handle_table_key(handle)?;
self.session_diag.stamp();
let result = self.readdir_inner(id, handle.clone()).await;
self.session_diag.stamp();
@@ -617,8 +627,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
/// read-past-end-of-file, so it is normal control flow on this
/// handler. The instrument attribute therefore omits err(Debug) and
/// non-Eof failures are surfaced via the explicit error log below.
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = %handle, offset, len))]
async fn read(&mut self, id: u32, handle: String, offset: u64, len: u32) -> Result<Data, Self::Error> {
#[tracing::instrument(level = "debug", skip(self), fields(id, handle = ?handle, offset, len))]
async fn read(&mut self, id: u32, handle: SftpHandle, offset: u64, len: u32) -> Result<Data, Self::Error> {
let handle = Self::handle_table_key(handle)?;
self.session_diag.stamp();
let result = self.read_inner(id, handle.clone(), offset, len).await;
self.session_diag.stamp();
@@ -650,8 +661,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
///
/// A missing handle is treated as Ok to tolerate clients that
/// double-close on session teardown.
#[tracing::instrument(level = "info", skip(self), fields(id, handle = %handle), err(Debug))]
async fn close(&mut self, id: u32, handle: String) -> Result<Status, Self::Error> {
#[tracing::instrument(level = "info", skip(self), fields(id, handle = ?handle), err(Debug))]
async fn close(&mut self, id: u32, handle: SftpHandle) -> Result<Status, Self::Error> {
let handle = Self::handle_table_key(handle)?;
self.session_diag.stamp();
let removed = self.handles.remove(&handle);
let Some(HandleState::Write {
@@ -755,8 +767,9 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
/// to Streaming by issuing CreateMultipartUpload. A Failed handle
/// rejects every subsequent write with the same status that caused
/// the failure.
#[tracing::instrument(level = "debug", skip(self, data), fields(id, handle = %handle, offset, len = data.len()), err(Debug))]
async fn write(&mut self, id: u32, handle: String, offset: u64, data: Vec<u8>) -> Result<Status, Self::Error> {
#[tracing::instrument(level = "debug", skip(self, data), fields(id, handle = ?handle, offset, len = data.len()), err(Debug))]
async fn write(&mut self, id: u32, handle: SftpHandle, offset: u64, data: Vec<u8>) -> Result<Status, Self::Error> {
let handle = Self::handle_table_key(handle)?;
self.session_diag.stamp();
self.enforce_server_readonly()?;
@@ -983,8 +996,8 @@ impl<S: StorageBackend + Send + Sync + 'static> russh_sftp::server::Handler for
/// SSH_FXP_FSETSTAT, SFTP Internet Draft section 6.6. Same rationale
/// as setstat: S3 cannot honour POSIX attributes, and clients use
/// FSETSTAT during transfers to stamp the in-flight handle.
#[tracing::instrument(level = "debug", skip(self, _attrs), fields(id, handle = %_handle), err(Debug))]
async fn fsetstat(&mut self, id: u32, _handle: String, _attrs: FileAttributes) -> Result<Status, Self::Error> {
#[tracing::instrument(level = "debug", skip(self, _attrs), fields(id, handle = ?_handle), err(Debug))]
async fn fsetstat(&mut self, id: u32, _handle: SftpHandle, _attrs: FileAttributes) -> Result<Status, Self::Error> {
self.enforce_server_readonly()?;
Ok(ok_status(id))
}
@@ -1254,7 +1267,7 @@ mod tests {
let handle_id = driver
.allocate_handle(file_handle("bucket", "k", 1234, attrs.clone()))
.expect("allocate");
let out = driver.fstat(4, handle_id).await.expect("fstat on File must succeed");
let out = driver.fstat(4, handle_id.into()).await.expect("fstat on File must succeed");
assert_eq!(out.attrs.size, Some(1234));
assert_eq!(out.attrs.mtime, Some(1_700_000_000));
}
@@ -1267,7 +1280,7 @@ mod tests {
part_buffer: vec![0u8; 4096],
};
let handle_id = driver.allocate_handle(write_handle("bucket", "k", phase)).expect("allocate");
let out = driver.fstat(5, handle_id).await.expect("fstat on Write must succeed");
let out = driver.fstat(5, handle_id.into()).await.expect("fstat on Write must succeed");
assert_eq!(
out.attrs.size,
Some(4096),
@@ -1283,7 +1296,7 @@ mod tests {
.allocate_handle(file_handle("bucket", "k", 0, FileAttributes::default()))
.expect("allocate");
let status = driver
.fsetstat(6, handle_id, FileAttributes::default())
.fsetstat(6, handle_id.into(), FileAttributes::default())
.await
.expect("fsetstat must succeed on any attrs");
assert!(matches!(status.status_code, StatusCode::Ok));
@@ -1417,7 +1430,7 @@ mod tests {
let handle_id = driver
.allocate_handle(file_handle("bucket", "k", 0, FileAttributes::default()))
.expect("allocate");
let result = driver.fsetstat(10, handle_id, FileAttributes::default()).await;
let result = driver.fsetstat(10, handle_id.into(), FileAttributes::default()).await;
match result {
Err(err) => assert!(matches!(err.0, StatusCode::PermissionDenied)),
Ok(_) => panic!("fsetstat must error in read-only mode"),
+26 -19
View File
@@ -69,7 +69,10 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
attrs,
read_cache,
})?;
Ok(Handle { id, handle })
Ok(Handle {
id,
handle: handle.into(),
})
}
/// Body of the SSH_FXP_READ handler. Returns up to len bytes starting
@@ -256,7 +259,7 @@ mod tests {
.allocate_handle(file_handle("bucket", "secret.txt", 4096, FileAttributes::default()))
.expect("allocate read handle");
driver.try_populate_read_cache(&handle, 0, vec![42; 4096]);
let error = with_test_auth_override(|_, _, _| true, driver.read(1, handle, 0, 1024))
let error = with_test_auth_override(|_, _, _| true, driver.read(1, handle.into(), 0, 1024))
.await
.expect_err("backend policy denial must prevent cached content disclosure");
assert!(matches!(StatusCode::from(error), StatusCode::PermissionDenied));
@@ -270,7 +273,7 @@ mod tests {
.allocate_handle(file_handle("bucket", "k", 100, FileAttributes::default()))
.expect("allocate");
let err = driver
.read(1, handle_id, 0, 0)
.read(1, handle_id.into(), 0, 0)
.await
.expect_err("len=0 must return BadMessage");
assert!(matches!(StatusCode::from(err), StatusCode::BadMessage));
@@ -284,7 +287,7 @@ mod tests {
.allocate_handle(file_handle("bucket", "k", 10, FileAttributes::default()))
.expect("allocate");
let err = driver
.read(2, handle_id, 10, 4)
.read(2, handle_id.into(), 10, 4)
.await
.expect_err("offset==size must return Eof");
assert!(matches!(StatusCode::from(err), StatusCode::Eof));
@@ -299,7 +302,7 @@ mod tests {
.allocate_handle(file_handle("bucket", "k", 5, FileAttributes::default()))
.expect("allocate");
let data = with_test_auth_override(|_, _, _| true, driver.read(3, handle_id, 0, 1024))
let data = with_test_auth_override(|_, _, _| true, driver.read(3, handle_id.into(), 0, 1024))
.await
.expect("read must succeed");
assert_eq!(data.data, b"hello".to_vec());
@@ -317,7 +320,7 @@ mod tests {
.allocate_handle(file_handle("bucket", "k", 10, FileAttributes::default()))
.expect("allocate");
let (result, captured) = capture_tracing_at(Level::ERROR, async { driver.read(11, handle_id, 10, 4).await }).await;
let (result, captured) = capture_tracing_at(Level::ERROR, async { driver.read(11, handle_id.into(), 10, 4).await }).await;
let err = result.expect_err("offset==size must return Eof");
assert!(matches!(StatusCode::from(err), StatusCode::Eof));
assert!(
@@ -342,8 +345,11 @@ mod tests {
.allocate_handle(file_handle("bucket", "k", 1024, FileAttributes::default()))
.expect("allocate");
let (result, captured) =
capture_tracing_at(Level::ERROR, with_test_auth_override(|_, _, _| true, driver.read(12, handle_id, 0, 256))).await;
let (result, captured) = capture_tracing_at(
Level::ERROR,
with_test_auth_override(|_, _, _| true, driver.read(12, handle_id.into(), 0, 256)),
)
.await;
let err = result.expect_err("backend error must propagate as Err");
assert!(!matches!(StatusCode::from(err), StatusCode::Eof), "backend error must not be Eof");
assert!(
@@ -379,7 +385,7 @@ mod tests {
let start = Instant::now();
let outcome = tokio::time::timeout(
Duration::from_secs(10),
with_test_auth_override(|_, _, _| true, driver.read(14, handle_id, 0, 4096)),
with_test_auth_override(|_, _, _| true, driver.read(14, handle_id.into(), 0, 4096)),
)
.await;
let elapsed = start.elapsed();
@@ -425,7 +431,7 @@ mod tests {
let mut assembled: Vec<u8> = Vec::with_capacity(object_size as usize);
let mut reads: u32 = 0;
while offset < object_size {
let data = with_test_auth_override(|_, _, _| true, driver.read(20 + reads, handle_id.clone(), offset, chunk))
let data = with_test_auth_override(|_, _, _| true, driver.read(20 + reads, handle_id.clone().into(), offset, chunk))
.await
.expect("read inside the cached window must succeed without a second backend call");
assert!(!data.data.is_empty(), "non-empty hit");
@@ -461,21 +467,21 @@ mod tests {
.expect("allocate");
// First read fetches from the backend and populates window 1.
let r1 = with_test_auth_override(|_, _, _| true, driver.read(30, handle_id.clone(), 0, 1024))
let r1 = with_test_auth_override(|_, _, _| true, driver.read(30, handle_id.clone().into(), 0, 1024))
.await
.expect("first read must succeed");
assert!(r1.data.iter().all(|b| *b == 0xAA), "first read must come from window 1");
// Second read inside the cached chunk is served from the
// buffer. No second backend call yet.
let r2 = with_test_auth_override(|_, _, _| true, driver.read(31, handle_id.clone(), 1024, 1024))
let r2 = with_test_auth_override(|_, _, _| true, driver.read(31, handle_id.clone().into(), 1024, 1024))
.await
.expect("mid-window read must succeed from cache");
assert!(r2.data.iter().all(|b| *b == 0xAA), "mid-window read still in window 1");
// Reading at offset == window falls outside the cached chunk
// and triggers the second backend call.
let r3 = with_test_auth_override(|_, _, _| true, driver.read(32, handle_id.clone(), window, 1024))
let r3 = with_test_auth_override(|_, _, _| true, driver.read(32, handle_id.clone().into(), window, 1024))
.await
.expect("read at offset=window must succeed via second backend call");
assert!(r3.data.iter().all(|b| *b == 0xBB), "read at window boundary must come from window 2");
@@ -483,7 +489,7 @@ mod tests {
// A read inside the second cached chunk is served from the
// buffer. The queue is empty by now, so any third backend
// call would fail.
let r4 = with_test_auth_override(|_, _, _| true, driver.read(33, handle_id, window + 1024, 1024))
let r4 = with_test_auth_override(|_, _, _| true, driver.read(33, handle_id.into(), window + 1024, 1024))
.await
.expect("mid-window-2 read must succeed from cache");
assert!(r4.data.iter().all(|b| *b == 0xBB), "mid-window-2 read still in window 2");
@@ -511,13 +517,13 @@ mod tests {
.expect("allocate");
// Populate window 1 with a full read.
let _ = with_test_auth_override(|_, _, _| true, driver.read(40, handle_id.clone(), 0, window as u32))
let _ = with_test_auth_override(|_, _, _| true, driver.read(40, handle_id.clone().into(), 0, window as u32))
.await
.expect("populate window 1");
// Ask for 256 bytes starting 64 bytes before window end. Only
// 64 bytes are in the window. The driver must return 64.
let edge = with_test_auth_override(|_, _, _| true, driver.read(41, handle_id, window - 64, 256))
let edge = with_test_auth_override(|_, _, _| true, driver.read(41, handle_id.into(), window - 64, 256))
.await
.expect("partial-hit read must succeed");
assert_eq!(edge.data.len(), 64, "partial hit must return only the in-window portion");
@@ -552,9 +558,10 @@ mod tests {
for i in 0..read_count {
let offset = (chunk_size as u64) * (i as u64);
let data = with_test_auth_override(|_, _, _| true, driver.read(50 + i, handle_id.clone(), offset, chunk_size as u32))
.await
.expect("each read must succeed via the backend");
let data =
with_test_auth_override(|_, _, _| true, driver.read(50 + i, handle_id.clone().into(), offset, chunk_size as u32))
.await
.expect("each read must succeed via the backend");
assert_eq!(data.data.len(), chunk_size, "read must return full requested length");
let expected_byte = (i + 1) as u8;
assert!(
+7 -4
View File
@@ -336,7 +336,10 @@ impl<S: StorageBackend + Send + Sync + 'static> SftpDriver<S> {
open_attrs,
phase: WritePhase::Buffering { part_buffer: Vec::new() },
})?;
Ok(Handle { id, handle })
Ok(Handle {
id,
handle: handle.into(),
})
}
/// Upload the buffered bytes to S3 with a single PutObject call.
@@ -2105,7 +2108,7 @@ mod tests {
)
.await
.expect("WRITE | CREATE | TRUNCATE on a missing file must allocate a handle");
assert!(!handle.handle.is_empty());
assert!(!handle.handle.as_bytes().is_empty());
assert!(backend.head_object_calls().is_empty(), "the non-EXCL accept path must not HEAD");
}
@@ -2130,7 +2133,7 @@ mod tests {
)
.await
.expect("WRITE | CREATE | TRUNCATE on an existing file must allocate a handle");
assert!(!handle.handle.is_empty());
assert!(!handle.handle.as_bytes().is_empty());
assert!(backend.head_object_calls().is_empty(), "the non-EXCL accept path must not HEAD");
}
@@ -2177,7 +2180,7 @@ mod tests {
)
.await
.expect("EXCL on a missing key must allow creation");
assert!(!handle.handle.is_empty());
assert!(!handle.handle.as_bytes().is_empty());
assert_eq!(backend.head_object_calls().len(), 1, "EXCL must HEAD exactly once");
}
-5
View File
@@ -38,8 +38,6 @@ default = []
# event. Requires `RUSTFLAGS="--cfg hyper_unstable_tracing"`.
diagnostic-internode-http2-ping = ["dep:hyper", "rustfs-io-metrics/diagnostic-internode-http2-ping"]
hotpath = [
"hotpath/hotpath",
"hotpath/tokio",
"rustfs-common/hotpath",
"rustfs-config/hotpath",
"rustfs-io-metrics/hotpath",
@@ -48,7 +46,6 @@ hotpath = [
]
hotpath-alloc = [
"hotpath",
"hotpath/hotpath-alloc",
"rustfs-common/hotpath-alloc",
"rustfs-config/hotpath-alloc",
"rustfs-io-metrics/hotpath-alloc",
@@ -57,7 +54,6 @@ hotpath-alloc = [
]
hotpath-cpu = [
"hotpath",
"hotpath/hotpath-cpu",
"rustfs-common/hotpath-cpu",
"rustfs-config/hotpath-cpu",
"rustfs-io-metrics/hotpath-cpu",
@@ -66,7 +62,6 @@ hotpath-cpu = [
]
[dependencies]
hotpath.workspace = true
rustfs-common.workspace = true
rustfs-heal-contracts.workspace = true
rustfs-io-metrics.workspace = true
-5
View File
@@ -31,29 +31,24 @@ workspace = true
[features]
default = []
hotpath = [
"hotpath/hotpath",
"hotpath/tokio",
"rustfs-rio/hotpath",
"rustfs-utils/hotpath",
"rustfs-filemeta/hotpath",
]
hotpath-alloc = [
"hotpath",
"hotpath/hotpath-alloc",
"rustfs-rio/hotpath-alloc",
"rustfs-utils/hotpath-alloc",
"rustfs-filemeta/hotpath-alloc",
]
hotpath-cpu = [
"hotpath",
"hotpath/hotpath-cpu",
"rustfs-rio/hotpath-cpu",
"rustfs-utils/hotpath-cpu",
"rustfs-filemeta/hotpath-cpu",
]
[dependencies]
hotpath.workspace = true
aes-gcm = { workspace = true, features = ["rand_core"] }
bytes = { workspace = true, features = ["serde"] }
chacha20poly1305.workspace = true
+4 -2
View File
@@ -32,6 +32,7 @@ workspace = true
internode-transport = []
default = []
hotpath = [
"dep:hotpath",
"hotpath/hotpath",
"hotpath/tokio",
"hotpath/futures",
@@ -59,7 +60,8 @@ hotpath-cpu = [
]
[dependencies]
hotpath.workspace = true
# Feature-gated in src (measure_block!); optional so default builds do not warn.
hotpath = { workspace = true, optional = true }
arc-swap.workspace = true
tokio = { workspace = true, features = ["io-util", "macros", "net", "rt-multi-thread", "sync", "time"] }
rand = { workspace = true, features = ["serde"] }
@@ -79,7 +81,6 @@ rustfs-io-metrics.workspace = true
rustfs-tls-runtime.workspace = true
rustfs-utils = { workspace = true, features = ["io", "hash", "compress"] }
serde_json = { workspace = true, features = ["raw_value"] }
md-5 = { workspace = true }
hmac.workspace = true
minlz.workspace = true
tracing.workspace = true
@@ -91,6 +92,7 @@ xxhash-rust = { workspace = true, features = ["xxh64", "xxh3"] }
hex-simd.workspace = true
[dev-dependencies]
md-5 = { workspace = true }
faster-hex.workspace = true
rcgen.workspace = true
tokio-rustls.workspace = true
+69 -163
View File
@@ -282,6 +282,19 @@ impl ScannerWorkSource {
}
}
fn from_code(code: u8) -> Option<Self> {
match code {
1 => Some(Self::Usage),
2 => Some(Self::Lifecycle),
3 => Some(Self::BucketReplication),
4 => Some(Self::SiteReplication),
5 => Some(Self::Heal),
6 => Some(Self::Bitrot),
7 => Some(Self::Alerts),
_ => None,
}
}
fn all() -> &'static [Self] {
&Self::ALL
}
@@ -962,34 +975,6 @@ impl ScannerUsagePublicationObservation {
}
}
#[derive(Clone, Copy, Default)]
struct LastScanCycle {
sequence: u64,
result: u8,
partial_reason: ScanCyclePartialReason,
partial_source: Option<ScannerWorkSource>,
partial_stage: Option<&'static str>,
duration_millis: u64,
}
/// Updates only this observation if a later state write fails. A supervisor
/// cancellation leaves the already recorded partial result and budget visible.
pub struct PartialCycleObservation<'a> {
latest: &'a Mutex<LastScanCycle>,
sequence: u64,
}
impl PartialCycleObservation<'_> {
pub fn observe_state_write(self, persisted: bool) {
if !persisted {
let mut last = self.latest.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if last.sequence == self.sequence {
last.partial_stage = Some("cycle_state_not_durable");
}
}
}
}
pub struct Metrics {
startup: crate::startup::ScannerStartupObservation,
operations: Vec<AtomicU64>,
@@ -1035,8 +1020,11 @@ pub struct Metrics {
scanner_leader_lock_held: AtomicBool,
scanner_leader_lock_last_error: RwLock<String>,
scanner_leader_lock_last_update_unix_secs: AtomicU64,
last_scan_cycle: Mutex<LastScanCycle>,
last_scan_cycle_result: AtomicU8,
last_scan_cycle_partial_reason: AtomicU8,
last_scan_cycle_partial_source: AtomicU8,
last_scan_cycle_end_unix_secs: AtomicU64,
last_scan_cycle_duration_millis: AtomicU64,
last_scan_cycle_objects_scanned: AtomicU64,
last_scan_cycle_directories_scanned: AtomicU64,
/// Lifetime count of object versions walked by the data scanner, counted
@@ -1152,6 +1140,7 @@ pub struct Metrics {
partial_scan_cycles: AtomicU64,
}
const SCAN_CYCLE_RESULT_UNKNOWN: u8 = 0;
const SCAN_CYCLE_RESULT_SUCCESS: u8 = 1;
const SCAN_CYCLE_RESULT_ERROR: u8 = 2;
const SCAN_CYCLE_RESULT_PARTIAL: u8 = 3;
@@ -1183,12 +1172,12 @@ impl ScanCyclePartialReason {
}
}
fn budget_stage(self) -> Option<&'static str> {
match self {
Self::Runtime => Some("runtime_budget"),
Self::Objects => Some("object_budget"),
Self::Directories => Some("directory_budget"),
Self::Unknown => None,
fn from_code(code: u8) -> Self {
match code {
1 => Self::Runtime,
2 => Self::Objects,
3 => Self::Directories,
_ => Self::Unknown,
}
}
}
@@ -1588,9 +1577,6 @@ pub struct ScannerMetricsReport {
pub last_cycle_partial_source: String,
#[serde(default)]
pub last_cycle_partial_source_code: u64,
/// First observed blocker for this partial cycle, including the exact budget when known.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub last_cycle_partial_stage: Option<String>,
pub last_cycle_duration_seconds: f64,
#[serde(default)]
pub last_cycle_objects_scanned: u64,
@@ -2085,18 +2071,8 @@ pub fn emit_scan_cycle_partial_with_source(
reason: ScanCyclePartialReason,
source: Option<ScannerWorkSource>,
) {
emit_scan_cycle_partial_with_stage(duration, reason, source, reason.budget_stage());
}
pub fn emit_scan_cycle_partial_with_stage(
duration: Duration,
reason: ScanCyclePartialReason,
source: Option<ScannerWorkSource>,
stage: Option<&'static str>,
) -> PartialCycleObservation<'static> {
let observation = global_metrics().record_scan_cycle_partial_with_stage(duration, reason, source, stage);
global_metrics().record_scan_cycle_partial_with_source(duration, reason, source);
metrics::counter!(OTEL_SCANNER_CYCLES, "result" => SCAN_CYCLE_RESULT_PARTIAL_LABEL).increment(1);
observation
}
pub fn emit_scan_cycle_superseded(duration: Duration) {
@@ -2197,8 +2173,11 @@ impl Metrics {
scanner_leader_lock_held: AtomicBool::new(false),
scanner_leader_lock_last_error: RwLock::new(String::new()),
scanner_leader_lock_last_update_unix_secs: AtomicU64::new(0),
last_scan_cycle: Mutex::new(LastScanCycle::default()),
last_scan_cycle_result: AtomicU8::new(SCAN_CYCLE_RESULT_UNKNOWN),
last_scan_cycle_partial_reason: AtomicU8::new(ScanCyclePartialReason::Unknown as u8),
last_scan_cycle_partial_source: AtomicU8::new(0),
last_scan_cycle_end_unix_secs: AtomicU64::new(0),
last_scan_cycle_duration_millis: AtomicU64::new(0),
last_scan_cycle_objects_scanned: AtomicU64::new(0),
last_scan_cycle_directories_scanned: AtomicU64::new(0),
lifetime_versions_scanned: AtomicU64::new(0),
@@ -3164,43 +3143,36 @@ impl Metrics {
self.failed_scan_cycles.fetch_add(1, Ordering::Relaxed);
SCAN_CYCLE_RESULT_ERROR
};
self.record_last_cycle(
duration,
LastScanCycle {
result,
..Default::default()
},
);
self.record_scanner_cycle_end_time();
self.last_scan_cycle_result.store(result, Ordering::Relaxed);
self.last_scan_cycle_partial_reason
.store(ScanCyclePartialReason::Unknown as u8, Ordering::Relaxed);
self.last_scan_cycle_partial_source.store(0, Ordering::Relaxed);
self.last_scan_cycle_duration_millis
.store(duration_millis_saturated(duration), Ordering::Relaxed);
}
pub fn record_scan_cycle_superseded(&self, duration: Duration) {
self.record_scanner_cycle_end_time();
self.superseded_scan_cycles.fetch_add(1, Ordering::Relaxed);
self.record_last_cycle(
duration,
LastScanCycle {
result: SCAN_CYCLE_RESULT_SUPERSEDED,
..Default::default()
},
);
self.last_scan_cycle_result
.store(SCAN_CYCLE_RESULT_SUPERSEDED, Ordering::Relaxed);
self.last_scan_cycle_partial_reason
.store(ScanCyclePartialReason::Unknown as u8, Ordering::Relaxed);
self.last_scan_cycle_partial_source.store(0, Ordering::Relaxed);
self.last_scan_cycle_duration_millis
.store(duration_millis_saturated(duration), Ordering::Relaxed);
}
pub fn record_scan_cycle_deferred(&self, duration: Duration) {
self.record_last_cycle(
duration,
LastScanCycle {
result: SCAN_CYCLE_RESULT_DEFERRED,
..Default::default()
},
);
}
fn record_last_cycle(&self, duration: Duration, mut cycle: LastScanCycle) -> u64 {
self.record_scanner_cycle_end_time();
cycle.duration_millis = duration_millis_saturated(duration);
let mut latest = self.last_scan_cycle.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
cycle.sequence = latest.sequence.wrapping_add(1);
*latest = cycle;
cycle.sequence
self.last_scan_cycle_result
.store(SCAN_CYCLE_RESULT_DEFERRED, Ordering::Relaxed);
self.last_scan_cycle_partial_reason
.store(ScanCyclePartialReason::Unknown as u8, Ordering::Relaxed);
self.last_scan_cycle_partial_source.store(0, Ordering::Relaxed);
self.last_scan_cycle_duration_millis
.store(duration_millis_saturated(duration), Ordering::Relaxed);
}
pub fn record_scan_cycle_partial(&self, duration: Duration, reason: ScanCyclePartialReason) {
@@ -3213,16 +3185,7 @@ impl Metrics {
reason: ScanCyclePartialReason,
source: Option<ScannerWorkSource>,
) {
self.record_scan_cycle_partial_with_stage(duration, reason, source, reason.budget_stage());
}
fn record_scan_cycle_partial_with_stage(
&self,
duration: Duration,
reason: ScanCyclePartialReason,
source: Option<ScannerWorkSource>,
stage: Option<&'static str>,
) -> PartialCycleObservation<'_> {
self.record_scanner_cycle_end_time();
self.partial_scan_cycles.fetch_add(1, Ordering::Relaxed);
match reason {
ScanCyclePartialReason::Unknown => &self.partial_scan_cycles_unknown,
@@ -3231,25 +3194,18 @@ impl Metrics {
ScanCyclePartialReason::Directories => &self.partial_scan_cycles_directories,
}
.fetch_add(1, Ordering::Relaxed);
self.last_scan_cycle_result
.store(SCAN_CYCLE_RESULT_PARTIAL, Ordering::Relaxed);
self.last_scan_cycle_partial_reason.store(reason as u8, Ordering::Relaxed);
self.last_scan_cycle_partial_source
.store(source.map(ScannerWorkSource::code).unwrap_or_default(), Ordering::Relaxed);
if let Some(source) = source
&& let Some(cycles) = self.partial_scan_cycles_by_source.get(source.index())
{
cycles.fetch_add(1, Ordering::Relaxed);
}
let sequence = self.record_last_cycle(
duration,
LastScanCycle {
result: SCAN_CYCLE_RESULT_PARTIAL,
partial_reason: reason,
partial_source: source,
partial_stage: stage,
..Default::default()
},
);
PartialCycleObservation {
latest: &self.last_scan_cycle,
sequence,
}
self.last_scan_cycle_duration_millis
.store(duration_millis_saturated(duration), Ordering::Relaxed);
}
pub fn start_scan_cycle_work(&self) -> ScanCycleWorkSnapshot {
@@ -3838,19 +3794,19 @@ impl Metrics {
m.current_disk_scan_concurrency_limit = disk_scan_concurrency_limit;
m.current_disk_bucket_scans_queued = disk_bucket_scans_queued;
m.current_disk_bucket_scans_active = disk_bucket_scans_active;
let last = *self.last_scan_cycle.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
m.last_cycle_result = scan_cycle_result_label(last.result).to_string();
m.last_cycle_result_code = last.result.into();
m.last_cycle_partial_reason = last.partial_reason.as_str().to_string();
m.last_cycle_partial_reason_code = last.partial_reason as u64;
m.last_cycle_partial_source = last
.partial_source
let last_cycle_result = self.last_scan_cycle_result.load(Ordering::Relaxed);
m.last_cycle_result = scan_cycle_result_label(last_cycle_result).to_string();
m.last_cycle_result_code = last_cycle_result as u64;
let partial_reason = ScanCyclePartialReason::from_code(self.last_scan_cycle_partial_reason.load(Ordering::Relaxed));
m.last_cycle_partial_reason = partial_reason.as_str().to_string();
m.last_cycle_partial_reason_code = partial_reason as u8 as u64;
let partial_source = ScannerWorkSource::from_code(self.last_scan_cycle_partial_source.load(Ordering::Relaxed));
m.last_cycle_partial_source = partial_source
.map(ScannerWorkSource::as_str)
.unwrap_or(SCAN_CYCLE_RESULT_UNKNOWN_LABEL)
.to_string();
m.last_cycle_partial_source_code = last.partial_source.map(|source| source.code().into()).unwrap_or_default();
m.last_cycle_partial_stage = last.partial_stage.map(str::to_owned);
m.last_cycle_duration_seconds = last.duration_millis as f64 / 1000.0;
m.last_cycle_partial_source_code = partial_source.map(|source| source.code().into()).unwrap_or_default();
m.last_cycle_duration_seconds = self.last_scan_cycle_duration_millis.load(Ordering::Relaxed) as f64 / 1000.0;
m.last_cycle_objects_scanned = self.last_scan_cycle_objects_scanned.load(Ordering::Relaxed);
m.last_cycle_directories_scanned = self.last_scan_cycle_directories_scanned.load(Ordering::Relaxed);
m.last_cycle_bucket_drive_scans = self.last_scan_cycle_bucket_drive_scans.load(Ordering::Relaxed);
@@ -5267,56 +5223,6 @@ mod tests {
assert_eq!(report.partial_cycles, 1);
}
#[tokio::test]
async fn delayed_partial_state_write_can_only_update_its_own_observation() {
let metrics = Metrics::new();
let record = || {
metrics.record_scan_cycle_partial_with_stage(
Duration::from_secs(1),
ScanCyclePartialReason::Runtime,
None,
Some("runtime_budget"),
)
};
let old = record();
let current = record();
assert_eq!(
metrics.report().await.partial_cycles,
2,
"both stops are visible before either state write finishes"
);
old.observe_state_write(false);
assert_eq!(metrics.report().await.last_cycle_partial_stage.as_deref(), Some("runtime_budget"));
current.observe_state_write(false);
let failed = metrics.report().await;
assert_eq!(failed.last_cycle_partial_stage.as_deref(), Some("cycle_state_not_durable"));
assert_eq!(failed.partial_cycles, 2);
assert_eq!(failed.last_cycle_partial_reason, "runtime");
let superseded = record();
metrics.record_scan_cycle_complete(true, Duration::ZERO);
superseded.observe_state_write(false);
assert!(metrics.report().await.last_cycle_partial_stage.is_none());
}
#[tokio::test]
async fn partial_stage_is_reported_with_the_last_result_and_cleared_on_completion() {
let metrics = Metrics::new();
metrics.record_scan_cycle_partial(Duration::from_secs(1), ScanCyclePartialReason::Directories);
let partial = serde_json::to_value(metrics.report().await).unwrap();
assert_eq!(partial["last_cycle_partial_reason"], "directories");
assert_eq!(partial["last_cycle_partial_stage"], "directory_budget");
metrics.record_scan_cycle_complete(true, Duration::from_secs(1));
let finished = serde_json::to_value(metrics.report().await).unwrap();
assert!(
!finished
.as_object()
.expect("serialized report")
.contains_key("last_cycle_partial_stage")
);
let legacy: ScannerMetricsReport = serde_json::from_value(finished).expect("older reports omit the stage");
assert_eq!(legacy.last_cycle_partial_stage, None);
}
#[tokio::test]
async fn report_tracks_partial_scan_cycle_without_failed_increment() {
let metrics = Metrics::new();
+1 -8
View File
@@ -73,7 +73,6 @@ hotpath-cpu = [
]
[dependencies]
tempfile.workspace = true
hotpath.workspace = true
rustfs-config = { workspace = true, features = ["server-config-model"] }
rustfs-common = { workspace = true }
@@ -109,13 +108,6 @@ uuid = { workspace = true, features = ["v4", "serde", "fast-rng"] }
bytes.workspace = true
hex-simd.workspace = true
[target.'cfg(any(target_os = "linux", target_os = "macos"))'.dependencies]
rustix = { workspace = true, features = ["fs"] }
[target.'cfg(windows)'.dependencies]
same-file.workspace = true
winapi-util.workspace = true
[dev-dependencies]
opentelemetry-proto.workspace = true
opentelemetry_sdk.workspace = true
@@ -126,6 +118,7 @@ rustfs-test-utils.workspace = true
tracing-subscriber = { workspace = true, features = ["json", "env-filter", "time"] }
serial_test = { workspace = true }
temp-env = { workspace = true, features = ["async_closure"] }
tempfile = { workspace = true }
uuid = { workspace = true, features = ["v4", "serde", "fast-rng", "macro-diagnostics"] }
tokio = { workspace = true, features = ["test-util", "fs", "rt-multi-thread"] }
# Test-only: pins the emitted scanner alert wire names against the canonical
+23 -145
View File
@@ -200,25 +200,10 @@ pub(crate) async fn read_config_revision<S: ScannerObjectIO>(store: Arc<S>, path
}
}
#[derive(Clone, Debug, Eq)]
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct DataUsageCacheRevisions {
main: DataUsageCacheRevision,
backup: Option<DataUsageCacheRevision>,
damaged_pages: DamagedPages,
}
// Admissions compare CAS tokens. A reader's local repair hint does not
// indicate that either committed object changed while its locks were released.
impl PartialEq for DataUsageCacheRevisions {
fn eq(&self, other: &Self) -> bool {
self.main == other.main && self.backup == other.backup
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct DamagedPages {
main: bool,
backup: bool,
}
pub static DATA_USAGE_BUCKET: LazyLock<String> =
@@ -591,31 +576,10 @@ pub(crate) struct DataUsageDurableProgress {
identity: Option<DataUsageScanIdentity>,
started_plan: Option<DataUsageScanPlanDigest>,
frontier: Option<String>,
dormant: HashMap<String, String>,
raw: HashMap<String, crate::raw_page_index::RawEnumerationDurableProgress>,
compacted: Vec<crate::scanner_folder::DirectoryProgress>,
listings: Vec<crate::scanner_folder::DirectoryReadProgress>,
active_source: Option<String>,
}
impl DataUsageDurableProgress {
fn source_frontier(&self, source: Option<&str>) -> Option<&str> {
if source == self.active_source.as_deref() {
self.frontier.as_deref()
} else {
source.and_then(|source| self.dormant.get(source)).map(String::as_str)
}
}
fn covers_on(&self, source: Option<&str>, path: &str) -> bool {
self.source_frontier(source)
.is_some_and(|frontier| scan_frontier_covers_path(path, frontier))
|| self
.compacted
.iter()
.any(|done| Some(done.physical.endpoint.as_str()) == source && done.covers(path))
}
pub(crate) fn advanced_from(&self, previous: &Self) -> bool {
if self.bucket != previous.bucket
|| self.source.is_none()
@@ -627,69 +591,31 @@ impl DataUsageDurableProgress {
{
return false;
}
let active = self.active_source.as_deref();
let old = previous.active_source.as_deref();
let switched = old.is_some() && active != old;
// A frontier can move from active to dormant without earning a turn.
// Retention and forward movement are compared only on the same source.
if previous.frontier.as_deref().is_some_and(|path| !self.covers_on(old, path))
|| previous
.dormant
.iter()
.any(|(source, path)| !self.covers_on(Some(source), path))
{
return false;
}
let mut advanced = self.frontier.as_deref().is_some_and(|now| {
previous
.source_frontier(active)
.is_none_or(|before| before != now && scan_frontier_covers_path(before, now))
});
if switched {
// Legacy raw-name pages are local to their writer. The physical
// root position must still exist for that writer across rotation.
if !previous.raw.is_empty()
&& !previous.listings.iter().any(|before| {
before.parent == self.bucket
&& Some(before.physical.endpoint.as_str()) == old
&& self.listings.iter().any(|after| after.extends(before))
})
{
return false;
}
} else {
for (parent, before) in &previous.raw {
match self.raw.get(parent) {
Some(after) if after.extends(before) => {}
None if self.covers_on(active, parent) => {}
_ => return false,
let mut advanced = match (&previous.frontier, &self.frontier) {
(Some(before), Some(after)) => {
if !scan_frontier_covers_path(before, after) {
return false;
}
before != after
}
advanced |= self.raw.iter().any(|(parent, after)| {
after.committed_entries() > previous.raw.get(parent).map_or(0, |before| before.committed_entries())
});
}
for before in &previous.listings {
if !self.listings.iter().any(|after| after.extends(before))
&& !self.covers_on(Some(&before.physical.endpoint), &before.parent)
{
return false;
(Some(_), None) => return false,
(None, Some(_)) => true,
(None, None) => false,
};
for (parent, before) in &previous.raw {
match self.raw.get(parent) {
Some(after) if after.extends(before) => {}
None if self
.frontier
.as_ref()
.is_some_and(|frontier| scan_frontier_covers_path(parent, frontier)) => {}
_ => return false,
}
}
for before in &previous.compacted {
if !self.compacted.iter().any(|after| after.extends(before))
&& !self.covers_on(Some(&before.physical.endpoint), &before.parent)
{
return false;
}
for (parent, after) in &self.raw {
let before = previous.raw.get(parent).map_or(0, |value| value.committed_entries());
advanced |= after.committed_entries() > before;
}
advanced |= self.listings.iter().any(|after| {
Some(after.physical.endpoint.as_str()) == active && !previous.listings.iter().any(|before| before.extends(after))
});
advanced |= self.compacted.iter().any(|after| {
Some(after.physical.endpoint.as_str()) == active && !previous.compacted.iter().any(|before| before.extends(after))
});
advanced
}
}
@@ -979,14 +905,6 @@ pub struct DataUsageCacheInfo {
pub scan_raw_enumeration_cursor: Option<DataUsageRawEnumerationCursor>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scan_raw_enumeration_page_index: Option<RawEnumerationPageIndex>,
/// Source-bound native listing positions and fully committed compacted work.
#[serde(default)]
pub scan_directory_work: Vec<crate::scanner_folder::DirectoryCheckpoint>,
/// Physical source of the regular linked tree and its frontier.
#[serde(default)]
pub scan_directory_source: Option<String>,
#[serde(default)]
pub scan_source_trees: std::collections::BTreeMap<String, Arc<source_tree::SourceTree>>,
/// Indexes of the other directories on the active walk path. A restart
/// must replay every wide ancestor before it reaches the selected one, and
/// recharging those replays would stop a fixed budget from ever advancing.
@@ -1076,9 +994,6 @@ impl Serialize for DataUsageCacheInfo {
+ usize::from(self.scan_raw_enumeration_cursor.is_some())
+ usize::from(self.scan_raw_enumeration_page_index.is_some())
+ usize::from(!self.scan_raw_enumeration_path_page_indexes.is_empty())
+ usize::from(!self.scan_directory_work.is_empty())
+ usize::from(self.scan_directory_source.is_some())
+ usize::from(!self.scan_source_trees.is_empty())
+ usize::from(self.scan_identity.is_some())
+ usize::from(self.scan_progress.is_some())
+ usize::from(self.scan_usage_watch.is_some())
@@ -1114,15 +1029,6 @@ impl Serialize for DataUsageCacheInfo {
if let Some(index) = &self.scan_raw_enumeration_page_index {
state.serialize_entry("scan_raw_enumeration_page_index", index)?;
}
if !self.scan_source_trees.is_empty() {
state.serialize_entry("scan_source_trees", &self.scan_source_trees)?;
}
if let Some(source) = &self.scan_directory_source {
state.serialize_entry("scan_directory_source", source)?;
}
if !self.scan_directory_work.is_empty() {
state.serialize_entry("scan_directory_work", &self.scan_directory_work)?;
}
if !self.scan_raw_enumeration_path_page_indexes.is_empty() {
state.serialize_entry("scan_raw_enumeration_path_page_indexes", &self.scan_raw_enumeration_path_page_indexes)?;
}
@@ -1330,25 +1236,6 @@ impl DataUsageCache {
identity: self.info.scan_identity,
started_plan: self.info.scan_progress.map(|progress| progress.started_plan),
frontier: self.validated_scan_frontier().map(str::to_owned),
dormant: self
.info
.scan_source_trees
.iter()
.filter_map(|(source, tree)| tree.frontier(&self.info).map(|last| (source.clone(), last.to_owned())))
.collect(),
active_source: self.info.scan_directory_source.clone(),
listings: self
.info
.scan_directory_work
.iter()
.filter_map(|d| d.read_progress(&self.info))
.collect(),
compacted: self
.info
.scan_directory_work
.iter()
.filter_map(|d| d.progress(&self.info))
.collect(),
raw: self
.info
.scan_raw_enumeration_page_index
@@ -1362,8 +1249,7 @@ impl DataUsageCache {
}
pub(crate) fn has_scan_position(&self) -> bool {
!self.info.scan_directory_work.is_empty()
|| self.info.scan_resume_after.is_some()
self.info.scan_resume_after.is_some()
|| self.info.scan_checkpoint.is_some()
|| self.info.scan_raw_enumeration_cursor.is_some()
|| self.info.scan_raw_enumeration_page_index.is_some()
@@ -1433,8 +1319,7 @@ impl DataUsageCache {
&& self.info.scan_identity == Some(identity)
&& (self.validated_scan_frontier().is_some()
|| self.validated_raw_enumeration_cursor().is_some()
|| self.validated_raw_enumeration_page_index().is_some()
|| self.info.scan_directory_work.iter().any(|d| d.is_bound_to(&self.info)));
|| self.validated_raw_enumeration_page_index().is_some());
let handoff_frontier = cross_epoch_checkpoint
.then(|| self.validated_scan_frontier().map(clone_cache_value))
.flatten();
@@ -1519,10 +1404,7 @@ impl DataUsageCache {
.take(MAX_DATA_USAGE_CACHE_DEPTH)
.filter(|index| self.raw_enumeration_page_index_is_valid(index))
.collect();
let directory_work = std::mem::take(&mut self.info.scan_directory_work);
self.info.scan_directory_work = directory_work.into_iter().filter(|d| d.is_bound_to(&self.info)).collect();
let cursor_is_valid = !self.has_scan_position()
|| !self.info.scan_directory_work.is_empty()
|| self.validated_scan_frontier().is_some()
|| self.info.scan_raw_enumeration_cursor.is_some()
|| self.info.scan_raw_enumeration_page_index.is_some();
@@ -1565,9 +1447,6 @@ impl DataUsageCache {
self.info.scan_raw_enumeration_cursor = None;
self.info.scan_raw_enumeration_page_index = None;
self.info.scan_raw_enumeration_path_page_indexes.clear();
self.info.scan_directory_work.clear();
self.info.scan_directory_source = None;
self.info.scan_source_trees.clear();
self.info.scan_coverage_receipt = None;
}
// Old readers do not understand coverage sweeps. An absent plan makes
@@ -2313,7 +2192,6 @@ impl DataUsageCache {
}
mod persistence;
mod source_tree;
#[derive(Default, Clone)]
struct Inner {
@@ -12,9 +12,6 @@
// See the License for the specific language governing permissions and
// limitations under the License.
mod pages;
mod scan_load;
use super::*;
use bytes::Bytes;
use std::sync::Arc;
@@ -74,7 +71,6 @@ struct DataUsageCacheLoadResult {
cache: DataUsageCache,
main_revision: DataUsageCacheRevision,
backup_revision: Option<DataUsageCacheRevision>,
damaged_pages: DamagedPages,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -111,42 +107,34 @@ impl DataUsageCache {
store: Arc<S>,
name: &str,
) -> StorageResult<DataUsageCacheRevisions> {
let backup_name = format!("{name}.bkp");
let backup_path = path_join_buf(&[BUCKET_META_PREFIX, &backup_name]);
let loaded = Self::load_cache(store.clone(), name).await?;
let backup = match loaded.backup_revision {
Some(revision) => Some(revision),
None => Self::backup_revision(store, name).await,
None => match read_config_revision(store, &backup_path).await {
Ok(revision) => Some(revision),
Err(err) => {
counter!(METRIC_CACHE_BACKUP_REVISION_FAILURE_TOTAL).increment(1);
debug!(
target: "rustfs::scanner::data_usage",
event = EVENT_SCANNER_CACHE_LOAD_STATE,
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_CACHE,
cache_name = %name,
backup_path = %backup_path,
state = "backup_revision_unavailable",
error = %err,
"Scanner cache backup revision lookup failed"
);
None
}
},
};
let main = loaded.main_revision;
*self = loaded.cache;
Ok(DataUsageCacheRevisions {
main,
backup,
damaged_pages: loaded.damaged_pages,
})
}
async fn backup_revision<S: ScannerObjectIO>(store: Arc<S>, name: &str) -> Option<DataUsageCacheRevision> {
let backup_name = format!("{name}.bkp");
let backup_path = path_join_buf(&[BUCKET_META_PREFIX, &backup_name]);
match read_config_revision(store, &backup_path).await {
Ok(revision) => Some(revision),
Err(err) => {
counter!(METRIC_CACHE_BACKUP_REVISION_FAILURE_TOTAL).increment(1);
debug!(
target: "rustfs::scanner::data_usage",
event = EVENT_SCANNER_CACHE_LOAD_STATE,
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_CACHE,
cache_name = %name,
backup_path = %backup_path,
state = "backup_revision_unavailable",
error = %err,
"Scanner cache backup revision lookup failed"
);
None
}
}
Ok(DataUsageCacheRevisions { main, backup })
}
pub(crate) async fn read_revisions<S: ScannerObjectIO>(store: Arc<S>, name: &str) -> StorageResult<DataUsageCacheRevisions> {
@@ -155,11 +143,7 @@ impl DataUsageCache {
let backup_path = path_join_buf(&[BUCKET_META_PREFIX, &backup_name]);
let main = read_config_revision(store.clone(), &main_path).await?;
let backup = Some(read_config_revision(store, &backup_path).await?);
Ok(DataUsageCacheRevisions {
main,
backup,
damaged_pages: DamagedPages::default(),
})
Ok(DataUsageCacheRevisions { main, backup })
}
async fn load_cache<S: ScannerObjectIO>(store: Arc<S>, name: &str) -> StorageResult<DataUsageCacheLoadResult> {
@@ -177,7 +161,6 @@ impl DataUsageCache {
cache: *cache,
main_revision,
backup_revision: None,
damaged_pages: DamagedPages::default(),
});
}
DataUsageCacheLoadAttempt::Loaded { revision: None, .. } => {
@@ -202,11 +185,6 @@ impl DataUsageCache {
let backup_name = format!("{name}.bkp");
let backup_attempt = Self::try_load_inner(store.clone(), &backup_name, Duration::from_secs(30)).await?;
let backup_revision = backup_attempt.revision();
if backup_revision.is_some()
&& let Some(DataUsageCacheRevision::Etag(etag)) = &main_revision
{
scan_load::PendingBackup::finish(&store, name, etag);
}
let backup_state = match backup_attempt {
DataUsageCacheLoadAttempt::Loaded {
cache,
@@ -220,10 +198,6 @@ impl DataUsageCache {
cache: *cache,
main_revision,
backup_revision: Some(backup_revision),
damaged_pages: DamagedPages {
main: main_state == DataUsageCacheLoadState::Corrupt,
backup: false,
},
});
}
DataUsageCacheLoadState::Loaded
@@ -247,10 +221,6 @@ impl DataUsageCache {
main_revision: main_revision
.ok_or_else(|| Error::other(format!("scanner cache missing state has no revision: {name}")))?,
backup_revision,
damaged_pages: DamagedPages {
main: main_state == DataUsageCacheLoadState::Corrupt,
backup: backup_state == DataUsageCacheLoadState::Corrupt,
},
});
}
(DataUsageCacheLoadState::Corrupt, DataUsageCacheLoadState::Missing)
@@ -270,10 +240,6 @@ impl DataUsageCache {
main_revision: main_revision
.ok_or_else(|| Error::other(format!("scanner cache corrupt state has no revision: {name}")))?,
backup_revision,
damaged_pages: DamagedPages {
main: main_state == DataUsageCacheLoadState::Corrupt,
backup: backup_state == DataUsageCacheLoadState::Corrupt,
},
});
}
_ => {}
@@ -329,35 +295,10 @@ impl DataUsageCache {
.filter(|etag| !etag.is_empty())
.cloned()
.map(DataUsageCacheRevision::Etag);
if let Some(DataUsageCacheRevision::Etag(etag)) = &revision
&& scan_load::PendingBackup::needs_backup(&store, load_name, etag)
{
return Ok((None, revision, true));
}
match reader.read_all().await {
Ok(data) => match Box::pin(pages::decode(store.clone(), load_name, &data)).await {
Ok(data) => match DataUsageCache::unmarshal(&data) {
Ok(cache) => Ok((Some(cache), revision, false)),
Err(err)
if matches!(err, StorageError::Io(ref io) if io.kind() == std::io::ErrorKind::InvalidData)
|| matches!(err, StorageError::FileNotFound | StorageError::ObjectNotFound(..))
|| (pages::is_manifest(&data) && pages::unreadable_page(&err)) =>
{
// A concurrent manifest commit can retire the generation
// we were reading. Retry the current root before treating
// missing pages as corruption or falling back to a backup.
if pages::is_manifest(&data) {
if Some(read_config_revision(store.clone(), &path).await?) != revision {
return Err(StorageError::PreconditionFailed);
}
if !load_name.ends_with(".bkp")
&& let Some(DataUsageCacheRevision::Etag(etag)) = &revision
{
scan_load::PendingBackup::begin(&store, load_name, etag);
}
}
Ok((None, revision, true))
}
Err(err) => Err(err),
Err(_) => Ok((None, revision, true)),
},
Err(e) => {
// Read error
@@ -711,44 +652,20 @@ impl DataUsageCache {
expected_epoch: Option<u64>,
) -> StorageResult<()> {
let serialize_started = Instant::now();
let paged = matches!((revisions, expected_epoch), (Some(_), Some(_))) && pages::eligible(self, name);
let encoded = if paged { Some(pages::encode(self)?) } else { None };
let inline = if paged {
Bytes::new()
} else {
let mut buf = Vec::new();
self.serialize(&mut rmp_serde::Serializer::new(&mut buf))?;
Bytes::from(buf)
};
counter!("rustfs_scanner_cache_serialized_bytes_total").increment(
encoded
.as_ref()
.map_or_else(|| u64::try_from(inline.len()).unwrap_or(u64::MAX), pages::EncodedPages::length),
);
let mut buf = Vec::new();
self.serialize(&mut rmp_serde::Serializer::new(&mut buf))?;
// Primary, backup, and retries read the same immutable encoded body.
let buf = Bytes::from(buf);
counter!("rustfs_scanner_cache_serialized_bytes_total").increment(u64::try_from(buf.len()).unwrap_or(u64::MAX));
histogram!("rustfs_scanner_cache_serialize_seconds").record(serialize_started.elapsed().as_secs_f64());
let timeout_duration = Self::cache_save_timeout();
let (primary_buf, primary_retired) = match (&encoded, revisions, expected_epoch) {
(Some(encoded), Some(revisions), Some(epoch)) => {
Box::pin(pages::prepare(
self,
store.clone(),
name,
&revisions.main,
encoded,
epoch,
revisions.damaged_pages.main,
))
.await?
}
_ => (inline.clone(), [None, None]),
};
let path = path_join_buf(&[BUCKET_META_PREFIX, name]);
let primary_save_started = Instant::now();
Self::save_path_with_retry(
store.clone(),
&path,
&primary_buf,
&buf,
timeout_duration,
DATA_USAGE_CACHE_SAVE_RETRIES,
revisions.map(|revisions| revisions.main.clone()),
@@ -756,7 +673,6 @@ impl DataUsageCache {
)
.await?;
pages::reclaim_retired(store.clone(), name, primary_retired, expected_epoch).await;
let backup_name = format!("{name}.bkp");
let backup_path = path_join_buf(&[BUCKET_META_PREFIX, &backup_name]);
let backup_timeout_duration = Self::backup_cache_save_timeout(timeout_duration, primary_save_started.elapsed());
@@ -764,36 +680,17 @@ impl DataUsageCache {
if revisions.is_some() && backup_revision.is_none() {
return Ok(());
}
let save_backup = async {
let (backup_buf, retired) = match (&encoded, &backup_revision, expected_epoch) {
(Some(encoded), Some(revision), Some(epoch)) => {
Box::pin(pages::prepare(
self,
store.clone(),
&backup_name,
revision,
encoded,
epoch,
revisions.is_some_and(|revisions| revisions.damaged_pages.backup),
))
.await?
}
_ => (inline, [None, None]),
};
Self::save_path_with_retry(
store.clone(),
&backup_path,
&backup_buf,
backup_timeout_duration,
DATA_USAGE_CACHE_BACKUP_SAVE_RETRIES,
backup_revision,
expected_epoch,
)
.await?;
pages::reclaim_retired(store, &backup_name, retired, expected_epoch).await;
Ok::<_, StorageError>(())
};
if let Err(e) = save_backup.await {
if let Err(e) = Self::save_path_with_retry(
store,
&backup_path,
&buf,
backup_timeout_duration,
DATA_USAGE_CACHE_BACKUP_SAVE_RETRIES,
backup_revision,
expected_epoch,
)
.await
{
warn!(
target: "rustfs::scanner::data_usage",
event = EVENT_SCANNER_CACHE_SAVE_STATE,
@@ -1,646 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
mod restore;
mod save;
mod staging;
use super::*;
use futures::future::try_join_all;
use sha2::Digest as _;
use std::collections::{BTreeMap, HashSet};
use std::io::Write;
use tokio::io::AsyncReadExt;
const PAGE_MIN: usize = 8 * 1024;
const PAGE_MAX: usize = 64 * 1024;
const FANOUT: usize = 128;
const IO_CONCURRENCY: usize = 4;
const PREFIX: &[u8] = b"\x83\xa7pagesV1";
type Digest = [u8; 32];
pub(super) type RetiredBundles = [Option<uuid::Uuid>; 2];
/// Older readers see the committed compact bucket or an incomplete empty tree.
#[derive(Deserialize)]
struct PageEnvelope {
#[serde(rename = "pagesV1")]
header: Header,
info: DataUsageCacheInfo,
#[serde(rename = "cache")]
_cache: serde::de::IgnoredAny,
}
#[derive(Debug, Serialize, Deserialize)]
struct Header {
body: Payload,
retired: Option<uuid::Uuid>,
#[serde(default, skip_serializing_if = "Option::is_none")]
abandoned: Option<uuid::Uuid>,
}
#[derive(Debug, Serialize, Deserialize)]
enum Payload {
Inline,
Pages(Manifest),
}
impl Header {
fn manifest(&self) -> Option<&Manifest> {
match &self.body {
Payload::Pages(manifest) => Some(manifest),
Payload::Inline => None,
}
}
fn retired_bundles(&self) -> RetiredBundles {
[self.retired, self.abandoned]
}
fn is_valid(&self) -> bool {
let live = self.manifest().map(|manifest| manifest.bundle);
self.manifest()
.is_none_or(|manifest| !manifest.bundle.is_nil() && manifest.length != 0 && manifest.level <= 9)
&& (self.abandoned.is_none() || self.abandoned != self.retired)
&& self
.retired_bundles()
.into_iter()
.flatten()
.all(|id| !id.is_nil() && Some(id) != live)
}
}
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
struct Manifest {
bundle: uuid::Uuid,
finished: bool,
cycle: u64,
length: u64,
level: u8,
root: Digest,
#[serde(default)]
bundle_bytes: u64,
#[serde(default)]
bundle_commits: u16,
}
#[derive(Debug, Default)]
struct Archive {
blocks: BTreeMap<Digest, Bytes>,
leaves: Vec<Digest>,
buffer: Vec<u8>,
rolling: u64,
length: u64,
}
fn invalid(message: &str) -> Error {
Error::Io(std::io::Error::new(std::io::ErrorKind::InvalidData, message.to_owned()))
}
pub(super) fn unreadable_page(error: &StorageError) -> bool {
matches!(error, StorageError::FileCorrupt)
|| matches!(error, StorageError::Io(io) if matches!(io.kind(), std::io::ErrorKind::InvalidData | std::io::ErrorKind::UnexpectedEof))
}
fn digest(data: &[u8]) -> Digest {
Sha256::digest(data).into()
}
fn bundle_prefix(name: &str, bundle: uuid::Uuid) -> String {
format!("{BUCKET_META_PREFIX}/{name}.pages/{bundle}/")
}
fn block_path(name: &str, bundle: uuid::Uuid, block: &Digest) -> String {
let hash = hex_simd::encode_to_string(block, hex_simd::AsciiCase::Lower);
format!("{}{hash}", bundle_prefix(name, bundle))
}
fn bucket_cache_name(name: &str) -> Option<&str> {
let (bucket, leaf) = name.split_once('/')?;
(!crate::is_reserved_or_invalid_bucket(bucket, true) && leaf == DATA_USAGE_CACHE_NAME).then_some(name)
}
// The high bits of a multiplicative hash of each byte give a rolling
// content-defined boundary. Insertion before a sealed run need not shift the
// offsets of every following page. Page length is bounded for every input.
const fn byte_gear(byte: u8) -> u64 {
let mut x = (byte as u64).wrapping_add(0x9e37_79b9_7f4a_7c15);
x = (x ^ (x >> 30)).wrapping_mul(0xbf58_476d_1ce4_e5b9);
x = (x ^ (x >> 27)).wrapping_mul(0x94d0_49bb_1331_11eb);
x ^ (x >> 31)
}
const GEAR: [u64; 256] = {
let mut table = [0; 256];
let mut byte = 0u8;
loop {
table[byte as usize] = byte_gear(byte);
if byte == u8::MAX {
break;
}
byte += 1;
}
table
};
impl Archive {
fn intern(&mut self, bytes: Vec<u8>) -> Digest {
let key = digest(&bytes);
self.blocks.entry(key).or_insert_with(|| Bytes::from(bytes));
key
}
fn seal(&mut self) {
if !self.buffer.is_empty() {
let bytes = std::mem::take(&mut self.buffer);
let key = self.intern(bytes);
self.leaves.push(key);
self.rolling = 0;
}
}
fn finish(&mut self, bundle: uuid::Uuid) -> StorageResult<Manifest> {
self.seal();
let mut children = std::mem::take(&mut self.leaves);
let mut level = 0;
while children.len() > 1 {
children = children
.chunks(FANOUT)
.map(|chunk| {
let bytes = chunk.iter().flatten().copied().collect();
self.intern(bytes)
})
.collect();
level += 1;
}
Ok(Manifest {
bundle,
finished: false,
cycle: 0,
length: self.length,
level,
root: children.pop().ok_or_else(|| invalid("empty scanner checkpoint"))?,
bundle_bytes: 0,
bundle_commits: 0,
})
}
}
impl Write for Archive {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
self.length = self
.length
.checked_add(u64::try_from(bytes.len()).map_err(std::io::Error::other)?)
.ok_or_else(|| std::io::Error::other("scanner checkpoint is too large"))?;
let mut start = 0;
for (offset, byte) in bytes.iter().enumerate() {
self.rolling = self.rolling.wrapping_shl(1).wrapping_add(GEAR[usize::from(*byte)]);
let end = offset + 1;
let len = self.buffer.len() + (end - start);
if len == PAGE_MAX || (len >= PAGE_MIN && self.rolling & 0x3fff == 0) {
self.buffer.extend_from_slice(&bytes[start..end]);
self.seal();
start = end;
}
}
self.buffer.extend_from_slice(&bytes[start..]);
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
Ok(())
}
}
pub(super) struct EncodedPages {
archive: Archive,
root: Manifest,
inline: Option<Bytes>,
}
impl EncodedPages {
pub(super) fn length(&self) -> u64 {
self.archive.length
}
}
pub(super) fn encode(cache: &DataUsageCache) -> StorageResult<EncodedPages> {
let mut archive = Archive::default();
archive.write_all(&[0x92])?;
cache.info.serialize(&mut rmp_serde::Serializer::new(&mut archive))?;
archive.seal();
let count = u32::try_from(cache.cache.len()).map_err(|_| invalid("too many scanner checkpoint entries"))?;
// A wide root's growing child set must not shift every subtree page.
let mut entries: Vec<_> = cache.cache.iter().collect();
entries.sort_unstable_by(|a, b| a.0.cmp(b.0));
let mut header = Vec::new();
if count < 16 {
header.push(0x80 | u8::try_from(count).map_err(|_| invalid("invalid fixed map length"))?);
} else if let Ok(n) = u16::try_from(count) {
header.push(0xde);
header.extend_from_slice(&n.to_be_bytes());
} else {
header.push(0xdf);
header.extend_from_slice(&count.to_be_bytes());
}
archive.write_all(&header)?;
for (name, entry) in entries {
let mut serializer = rmp_serde::Serializer::new(&mut archive);
name.serialize(&mut serializer)?;
entry.ordered_encoding().serialize(&mut serializer)?;
if name == &cache.info.name {
archive.seal();
}
}
archive.seal();
let inline = if archive.length <= PAGE_MIN as u64 {
let mut buf = Vec::new();
for key in &archive.leaves {
buf.extend_from_slice(
archive
.blocks
.get(key)
.ok_or_else(|| invalid("missing encoded scanner page"))?,
);
}
Some(Bytes::from(buf))
} else {
None
};
let root = archive.finish(uuid::Uuid::nil())?;
Ok(EncodedPages { archive, root, inline })
}
pub(super) fn is_manifest(bytes: &[u8]) -> bool {
bytes.starts_with(PREFIX)
}
fn read_envelope(bytes: &[u8], bucket: &str) -> StorageResult<PageEnvelope> {
let head: PageEnvelope = rmp_serde::from_slice(bytes).map_err(|_| invalid("invalid scanner checkpoint manifest"))?;
if head.info.name != bucket || !head.header.is_valid() {
return Err(invalid("invalid scanner checkpoint identity or size"));
}
Ok(head)
}
async fn read_block<S: ScannerObjectIO>(store: Arc<S>, name: &str, bundle: uuid::Uuid, key: Digest) -> StorageResult<Bytes> {
let path = block_path(name, bundle, &key);
let mut reader = store
.get_object_reader(
RUSTFS_META_BUCKET,
&path,
None,
HeaderMap::new(),
&ObjectOptions {
no_lock: true,
..Default::default()
},
)
.await?;
if reader.object_info.size < 1 || usize::try_from(reader.object_info.size).map_or(true, |size| size > PAGE_MAX) {
return Err(invalid("invalid scanner checkpoint page length"));
}
let bytes = Bytes::from(reader.read_all().await?);
if bytes.len() > PAGE_MAX || digest(&bytes) != key {
return Err(invalid("scanner checkpoint page checksum mismatch"));
}
Ok(bytes)
}
async fn committed_keys<S: ScannerObjectIO>(
store: Arc<S>,
name: &str,
manifest: &Manifest,
candidate: &Archive,
) -> StorageResult<HashSet<Digest>> {
let mut keys = vec![manifest.root];
let mut known = HashSet::from([manifest.root]);
for _ in 0..manifest.level {
let parents = std::mem::take(&mut keys);
for batch in parents.chunks(IO_CONCURRENCY) {
let mut reads = Vec::new();
let mut nodes = Vec::with_capacity(batch.len());
for &key in batch {
// The committed parent authenticates the table digest.
// Unchanged tables are already available in the candidate.
if let Some(node) = candidate.blocks.get(&key) {
nodes.push(node.clone());
} else {
reads.push(read_block(store.clone(), name, manifest.bundle, key));
}
}
nodes.extend(try_join_all(reads).await?);
for node in nodes {
if node.is_empty() || node.len() > FANOUT * 32 || node.len() % 32 != 0 {
return Err(invalid("invalid scanner checkpoint page table"));
}
for &key in node.as_chunks::<32>().0 {
keys.push(key);
known.insert(key);
}
if u64::try_from(keys.len()).unwrap_or(u64::MAX) > manifest.length.div_ceil(PAGE_MIN as u64).saturating_add(3) {
return Err(invalid("scanner checkpoint contains excess page references"));
}
}
}
}
Ok(known)
}
pub(super) async fn decode<S: ScannerObjectIO>(store: Arc<S>, load_name: &str, bytes: &[u8]) -> StorageResult<DataUsageCache> {
if !is_manifest(bytes) {
return DataUsageCache::unmarshal(bytes).map_err(|_| invalid("invalid scanner cache"));
}
let name = load_name.strip_suffix(".bkp").unwrap_or(load_name);
let bucket = bucket_cache_name(name)
.and_then(|name| name.split_once('/'))
.ok_or_else(|| invalid("misplaced scanner checkpoint"))?
.0;
let head = read_envelope(bytes, bucket)?;
let Some(manifest) = head.header.manifest() else {
return DataUsageCache::unmarshal(bytes).map_err(|_| invalid("invalid inline scanner checkpoint"));
};
let cache = restore::restore(store, load_name, manifest).await?;
if cache.info.name != bucket
|| cache.info.snapshot_complete != manifest.finished
|| cache.info.next_cycle != manifest.cycle
|| cache.info.scan_identity != head.info.scan_identity
|| cache.info.source != head.info.source
|| cache.info.leader_epoch != head.info.leader_epoch
|| cache.info.next_cycle != head.info.next_cycle
{
return Err(invalid("scanner checkpoint scope changed"));
}
Ok(cache)
}
async fn previous_header<S: ScannerObjectIO>(
store: Arc<S>,
name: &str,
revision: &DataUsageCacheRevision,
) -> StorageResult<Option<Header>> {
if *revision == DataUsageCacheRevision::Missing {
return Ok(None);
}
let path = path_join_buf(&[BUCKET_META_PREFIX, name]);
let mut reader = store
.get_object_reader(
RUSTFS_META_BUCKET,
&path,
None,
HeaderMap::new(),
&ObjectOptions {
no_lock: true,
..Default::default()
},
)
.await?;
if reader
.object_info
.etag
.as_ref()
.map(|etag| DataUsageCacheRevision::Etag(etag.clone()))
.as_ref()
!= Some(revision)
{
return Err(StorageError::PreconditionFailed);
}
// Header is the first value in the envelope. A large compatibility
// projection or legacy cache does not require reading its body here.
let mut prefix = Vec::new();
(&mut reader).take(1024).read_to_end(&mut prefix).await?;
if !is_manifest(&prefix) {
return Ok(None);
}
let mut deserializer = rmp_serde::Deserializer::new(&prefix[PREFIX.len()..]);
// A damaged old header cannot participate in reuse or reclamation.
// Rebuilding uses the CAS revision obtained by the normal loader.
Ok(Header::deserialize(&mut deserializer).ok().filter(Header::is_valid))
}
fn build_bundle(name: &str, revision: &DataUsageCacheRevision, cache: &DataUsageCache) -> uuid::Uuid {
// Before the first root CAS, retries and competing builders populate the
// same staging namespace. Individual page names are immutable digests.
let mut hash = Sha256::new();
hash.update(b"rustfs-scanner-checkpoint-v1\0");
hash.update(name.as_bytes());
if let Some(identity) = cache.info.scan_identity {
hash.update(identity.bucket_incarnation.as_bytes());
}
if let DataUsageCacheRevision::Etag(etag) = revision {
hash.update(etag.as_bytes());
}
let mut id = [0; 16];
id.copy_from_slice(&hash.finalize()[..16]);
uuid::Uuid::from_bytes(id)
}
pub(super) fn eligible(cache: &DataUsageCache, name: &str) -> bool {
bucket_cache_name(name).is_some()
&& cache.info.scan_identity.is_some()
&& cache.info.name == name.split('/').next().unwrap_or("")
}
pub(super) async fn prepare<S: ScannerObjectIO + ScannerConfigObjectDelete>(
cache: &DataUsageCache,
store: Arc<S>,
name: &str,
revision: &DataUsageCacheRevision,
encoded: &EncodedPages,
epoch: u64,
damaged: bool,
) -> StorageResult<(Bytes, RetiredBundles)> {
let previous_header = previous_header(store.clone(), name, revision).await?;
let previous = previous_header.as_ref().and_then(Header::manifest);
let [mut retired, mut abandoned] = previous_header.as_ref().map_or([None, None], Header::retired_bundles);
for pending in [&mut retired, &mut abandoned] {
if let Some(id) = *pending
&& reclaim(store.clone(), name, id, epoch).await.is_ok()
{
*pending = None;
}
}
// A marker lives beside a new bundle's pages and commits before any of
// them. We can rediscover that bundle even if the writer never committed
// its manifest or retained its in-memory write receipts.
let candidate = build_bundle(name, revision, cache);
let marker = format!("{}staging", bundle_prefix(name, candidate));
let has_marker = match read_config_revision(store.clone(), &marker).await {
Ok(revision) => revision != DataUsageCacheRevision::Missing,
Err(error) if unreadable_page(&error) => true,
Err(error) => return Err(error),
};
let allow_rotation = retired.is_none() && abandoned.is_none();
let inline = encoded.inline.as_ref().filter(|_| previous.is_none() || allow_rotation);
let live_bytes = save::block_bytes(encoded.archive.blocks.values());
let reuse = match previous {
Some(head) if inline.is_none() && !damaged && !(head.finished && head.cycle != cache.info.next_cycle) => {
save::reuse(store.clone(), name, head, &encoded.archive, live_bytes).await?
}
_ => None,
};
if (inline.is_some() || reuse.is_some()) && has_marker && previous.is_none_or(|head| head.bundle != candidate) {
if abandoned.is_some_and(|pending| pending != candidate) {
return Err(Error::other(
"cannot abandon scanner checkpoint before reclaiming its previous staging bundle",
));
}
abandoned = Some(candidate);
}
if let Some(inline) = inline {
retired = retired.or_else(|| previous.map(|head| head.bundle));
let header = Header {
body: Payload::Inline,
retired,
abandoned,
};
let cleanup = header.retired_bundles();
if cleanup == [None, None] {
return Ok((inline.clone(), cleanup));
}
let bytes = rmp_serde::to_vec_named(&CompatibilityEnvelope {
header: &header,
info: &cache.info,
cache: &cache.cache,
})
.map_err(|_| invalid("failed to encode inline scanner checkpoint"))?;
return Ok((Bytes::from(bytes), cleanup));
}
let verify_backup = name.ends_with(".bkp");
let (bundle, known, bundle_bytes, bundle_commits) = if let Some((head, known, total)) = reuse {
(head.bundle, known, total, head.bundle_commits + 1)
} else {
if !allow_rotation {
// Keep the readable generations and their cleanup obligations.
return Err(Error::other("cannot rotate scanner checkpoint before reclaiming its retired bundle"));
}
retired = previous.map(|head| head.bundle);
(candidate, HashSet::new(), live_bytes, 1)
};
let reserve_candidate = || async {
if !has_marker {
DataUsageCache::save_path_with_retry(
store.clone(),
&marker,
&Bytes::from_static(b"scanner checkpoint staging"),
DataUsageCache::cache_save_timeout(),
DATA_USAGE_CACHE_SAVE_RETRIES,
Some(DataUsageCacheRevision::Missing),
Some(epoch),
)
.await?;
}
Ok::<(), StorageError>(())
};
if bundle == candidate {
reserve_candidate().await?;
}
let mut manifest = encoded.root.clone();
manifest.bundle = bundle;
manifest.finished = cache.info.snapshot_complete;
manifest.cycle = cache.info.next_cycle;
manifest.bundle_bytes = bundle_bytes;
manifest.bundle_commits = bundle_commits;
if let Err(error) = save::stage(store.clone(), name, revision, epoch, &manifest, &encoded.archive, &known).await {
// A corrupt XL header need not yield an ETag for a conditional repair.
// Rebuild this backup under a fresh namespace; its old root stays visible
// until the manifest CAS. Other I/O failures remain retryable in place.
if !(verify_backup && manifest.bundle_commits > 1 && allow_rotation && unreadable_page(&error)) {
return Err(error);
}
retired = Some(manifest.bundle);
abandoned = None;
manifest.bundle = candidate;
reserve_candidate().await?;
manifest.bundle_bytes = live_bytes;
manifest.bundle_commits = 1;
save::stage(store.clone(), name, revision, epoch, &manifest, &encoded.archive, &HashSet::new()).await?;
}
let header = Header {
body: Payload::Pages(manifest),
retired,
abandoned,
};
let cleanup = header.retired_bundles();
let projection = |info: &DataUsageCacheInfo, cache: &BTreeMap<String, DataUsageEntry>| {
rmp_serde::to_vec_named(&CompatibilityEnvelope {
header: &header,
info,
cache,
})
.map_err(|_| invalid("failed to encode scanner checkpoint root"))
};
if cache.info.snapshot_complete {
// Older readers can serve compact totals when the compatibility
// projection fits. The manifest remains bounded even with many
// pending repairs or a large lifecycle configuration.
let mut root = cache
.checked_flatten_complete_scope(&cache.info.name)
.ok_or_else(|| invalid("disconnected complete bucket checkpoint"))?;
root.compacted = true;
let bytes = projection(&cache.info, &BTreeMap::from([(cache.info.name.clone(), root)]))?;
if bytes.len() <= PAGE_MIN {
return Ok((Bytes::from(bytes), cleanup));
}
}
let info = DataUsageCacheInfo {
name: cache.info.name.clone(),
source: cache.info.source,
scan_identity: cache.info.scan_identity,
leader_epoch: cache.info.leader_epoch,
next_cycle: cache.info.next_cycle,
..Default::default()
};
let bytes = projection(&info, &BTreeMap::new())?;
Ok((Bytes::from(bytes), cleanup))
}
#[derive(Serialize)]
struct CompatibilityEnvelope<'a, T> {
#[serde(rename = "pagesV1")]
header: &'a Header,
info: &'a DataUsageCacheInfo,
cache: &'a T,
}
pub(super) async fn reclaim_retired<S: ScannerObjectIO + ScannerConfigObjectDelete>(
store: Arc<S>,
name: &str,
bundles: RetiredBundles,
epoch: Option<u64>,
) {
if let Some(epoch) = epoch {
for bundle in bundles.into_iter().flatten() {
let _ = reclaim(store.clone(), name, bundle, epoch).await;
}
}
}
async fn reclaim<S: ScannerObjectIO + ScannerConfigObjectDelete>(
store: Arc<S>,
name: &str,
bundle: uuid::Uuid,
epoch: u64,
) -> StorageResult<()> {
let _admission = scanner_publication_admission_for_epoch(store.clone(), epoch)
.await
.ok_or_else(cache_publication_epoch_changed)?;
let prefix = bundle_prefix(name, bundle);
let opts = ObjectOptions {
delete_prefix: true,
..Default::default()
};
match timeout(
DataUsageCache::cache_save_timeout(),
store.delete_config_object(RUSTFS_META_BUCKET, &prefix, opts),
)
.await
{
Ok(Ok(_)) | Ok(Err(StorageError::FileNotFound | StorageError::ObjectNotFound(..))) => Ok(()),
Ok(Err(error)) => Err(error),
Err(_) => Err(Error::other("retired scanner checkpoint cleanup timed out")),
}
}
@@ -1,207 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::super::scan_load::park_restore;
use super::*;
use std::any::Any;
use std::fs::File;
use std::io::{Seek, SeekFrom};
use std::sync::{Mutex, Weak};
use tokio::time::Instant as WallInstant;
const MEMORY_LIMIT: u64 = 1024 * 1024;
const PARKED_LIMIT: usize = 32;
enum Buffer {
Memory(Vec<u8>),
File(Arc<Mutex<File>>),
}
struct Position {
pending: Vec<(Digest, u8)>,
length: u64,
leaves: u64,
nodes: u64,
buffer: Buffer,
writer: Option<tokio::task::JoinHandle<std::io::Result<()>>>,
decoder: Option<tokio::task::JoinHandle<StorageResult<DataUsageCache>>>,
}
struct Suspended {
owner: Weak<dyn Any + Send + Sync>,
name: String,
manifest: Manifest,
last_polled: WallInstant,
position: Position,
}
struct Recovery(Option<Suspended>);
static PARKED: LazyLock<Mutex<Vec<Suspended>>> = LazyLock::new(|| Mutex::new(Vec::new()));
impl Recovery {
async fn open<S: ScannerObjectIO>(store: &Arc<S>, name: &str, manifest: &Manifest) -> StorageResult<Self> {
let erased: Arc<dyn Any + Send + Sync> = store.clone();
let owner = Arc::downgrade(&erased);
let resumed = {
let mut parked = PARKED.lock().unwrap_or_else(|error| error.into_inner());
parked.retain(|job| {
job.owner.strong_count() != 0 && (!job.owner.ptr_eq(&owner) || job.name != name || job.manifest == *manifest)
});
parked
.iter()
.position(|job| job.owner.ptr_eq(&owner) && job.name == name && job.manifest == *manifest)
.map(|index| parked.swap_remove(index))
};
if let Some(mut job) = resumed {
job.last_polled = WallInstant::now();
return Ok(Self(Some(job)));
}
let buffer = if manifest.length <= MEMORY_LIMIT {
Buffer::Memory(Vec::new())
} else {
let file = tokio::task::spawn_blocking(tempfile::tempfile)
.await
.map_err(Error::other)??;
Buffer::File(Arc::new(Mutex::new(file)))
};
Ok(Self(Some(Suspended {
owner,
name: name.to_owned(),
manifest: manifest.clone(),
last_polled: WallInstant::now(),
position: Position {
pending: vec![(manifest.root, manifest.level)],
length: 0,
leaves: 0,
nodes: 0,
buffer,
writer: None,
decoder: None,
},
})))
}
}
// Park only verified bytes and traversal state. Outstanding metadata reads
// and their admissions are dropped with the waiter. A local spool write or
// decode may finish after cancellation and is joined before advancing again.
impl Drop for Recovery {
fn drop(&mut self) {
let Some(mut job) = self.0.take() else { return };
if job.position.nodes == 0 && job.position.leaves == 0 {
return;
}
let mut parked = PARKED.lock().unwrap_or_else(|error| error.into_inner());
job.last_polled = WallInstant::now();
if let Some(previous) = parked
.iter_mut()
.find(|previous| previous.owner.ptr_eq(&job.owner) && previous.name == job.name && previous.manifest == job.manifest)
{
// Readers of an immutable root traverse the same ordered prefix.
// Keep the furthest admission regardless of cancellation order.
if job.position.verified_progress() > previous.position.verified_progress() {
std::mem::swap(previous, &mut job);
}
} else {
let displaced = park_restore(&mut parked, PARKED_LIMIT, job, |job| job.last_polled);
drop(parked);
drop(displaced);
}
}
}
impl Position {
fn verified_progress(&self) -> (u64, bool) {
(self.nodes + self.leaves, self.decoder.is_some())
}
async fn restore<S: ScannerObjectIO>(
&mut self,
store: Arc<S>,
name: &str,
manifest: &Manifest,
) -> StorageResult<DataUsageCache> {
let max_leaves = manifest.length.div_ceil(PAGE_MIN as u64).saturating_add(3);
loop {
// Retain the local write across cancellation. The verified page already
// owns its offset and must not consume another storage read next round.
if let Some(writer) = &mut self.writer {
writer.await.map_err(Error::other)??;
self.writer = None;
}
let Some(&(key, level)) = self.pending.last() else { break };
if level != 0 {
let node = read_block(store.clone(), name, manifest.bundle, key).await?;
if node.is_empty()
|| node.len() > FANOUT * 32
|| node.len() % 32 != 0
|| self.nodes >= max_leaves.saturating_mul(u64::from(manifest.level))
{
return Err(invalid("invalid scanner checkpoint restore table"));
}
self.pending.pop();
for &child in node.as_chunks::<32>().0.iter().rev() {
self.pending.push((child, level - 1));
}
self.nodes += 1;
continue;
}
let block = read_block(store.clone(), name, manifest.bundle, key).await?;
let next = self
.length
.checked_add(u64::try_from(block.len()).map_err(|_| invalid("invalid restore length"))?)
.filter(|len| *len <= manifest.length)
.ok_or_else(|| invalid("scanner checkpoint exceeds its committed length"))?;
if self.leaves >= max_leaves {
return Err(invalid("too many scanner checkpoint leaves"));
}
match &mut self.buffer {
Buffer::Memory(bytes) => bytes.extend_from_slice(&block),
Buffer::File(file) => {
let file = file.clone();
let offset = self.length;
self.writer = Some(tokio::task::spawn_blocking(move || {
let mut file = file.lock().unwrap_or_else(|error| error.into_inner());
file.seek(SeekFrom::Start(offset))?;
file.write_all(&block)
}));
}
}
self.pending.pop();
self.length = next;
self.leaves += 1;
}
if self.length != manifest.length {
return Err(invalid("incomplete scanner checkpoint"));
}
let job = self.decoder.get_or_insert_with(|| {
let buffer = std::mem::replace(&mut self.buffer, Buffer::Memory(Vec::new()));
tokio::task::spawn_blocking(move || {
let result = match buffer {
Buffer::Memory(bytes) => rmp_serde::from_slice(&bytes),
Buffer::File(file) => {
let mut file = file.lock().unwrap_or_else(|error| error.into_inner());
file.seek(SeekFrom::Start(0))?;
rmp_serde::from_read(std::io::BufReader::new(&mut *file))
}
};
result.map_err(|_| invalid("invalid scanner checkpoint payload"))
})
});
job.await.map_err(Error::other)?
}
}
pub(super) async fn restore<S: ScannerObjectIO>(store: Arc<S>, name: &str, manifest: &Manifest) -> StorageResult<DataUsageCache> {
let mut job = Recovery::open(&store, name, manifest).await?;
let result = job
.0
.as_mut()
.ok_or_else(|| invalid("missing checkpoint restore state"))?
.position
.restore(store, name, manifest)
.await;
job.0.take();
result
}
@@ -1,138 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
// A losing writer can stage blocks without publishing its accounting. Even
// tiny or identical successful checkpoints periodically retire these orphans.
const MAX_BUNDLE_COMMITS: u16 = 256;
pub(super) fn block_bytes<'a>(blocks: impl Iterator<Item = &'a Bytes>) -> u64 {
blocks.fold(0u64, |sum, bytes| sum.saturating_add(u64::try_from(bytes.len()).unwrap_or(u64::MAX)))
}
pub(super) async fn reuse<'a, S: ScannerObjectIO>(
store: Arc<S>,
name: &str,
head: &'a Manifest,
candidate: &Archive,
live: u64,
) -> StorageResult<Option<(&'a Manifest, HashSet<Digest>, u64)>> {
// Legacy manifests did not account for unreachable blocks in this bundle.
if head.bundle_bytes == 0 || head.bundle_commits == 0 || head.bundle_commits >= MAX_BUNDLE_COMMITS {
return Ok(None);
}
let known = match committed_keys(store, name, head, candidate).await {
Ok(known) => known,
Err(StorageError::FileNotFound | StorageError::ObjectNotFound(..)) => return Ok(None),
Err(error) if unreadable_page(&error) => return Ok(None),
Err(error) => return Err(error),
};
// Count reachable allocation once at bundle creation and newly staged
// bytes thereafter. A small delta stays incremental even across cycles.
let added = block_bytes(
candidate
.blocks
.iter()
.filter_map(|(key, bytes)| (!known.contains(key)).then_some(bytes)),
);
let total = head.bundle_bytes.checked_add(added);
Ok(total
.filter(|&total| total <= live.saturating_mul(2))
.map(|total| (head, known, total)))
}
/// Returns the conditional write necessary to restore this content-addressed
/// backup page, or None when the bytes in storage already match the candidate.
async fn backup_revision<S: ScannerObjectIO>(
store: &S,
path: &str,
expected: &Bytes,
) -> StorageResult<Option<DataUsageCacheRevision>> {
let mut reader = match store
.get_object_reader(
RUSTFS_META_BUCKET,
path,
None,
HeaderMap::new(),
&ObjectOptions {
no_lock: true,
..Default::default()
},
)
.await
{
Ok(reader) => reader,
Err(StorageError::FileNotFound | StorageError::ObjectNotFound(..)) => return Ok(Some(DataUsageCacheRevision::Missing)),
Err(error) => return Err(error),
};
if usize::try_from(reader.object_info.size).ok() == Some(expected.len()) {
let mut bytes = Vec::with_capacity(expected.len());
(&mut reader).take(PAGE_MAX as u64 + 1).read_to_end(&mut bytes).await?;
if bytes == expected.as_ref() {
return Ok(None);
}
}
let etag = reader
.object_info
.etag
.ok_or_else(|| invalid("damaged scanner backup page has no revision"))?;
Ok(Some(DataUsageCacheRevision::Etag(etag)))
}
pub(super) async fn stage<S: ScannerObjectIO + ScannerConfigObjectDelete>(
store: Arc<S>,
name: &str,
revision: &DataUsageCacheRevision,
epoch: u64,
manifest: &Manifest,
archive: &Archive,
known: &HashSet<Digest>,
) -> StorageResult<()> {
let verify_backup = name.ends_with(".bkp");
let staging = staging::Staging::open(&store, name, manifest.bundle, epoch, revision);
let mut writes = Vec::with_capacity(IO_CONCURRENCY);
for (key, bytes) in &archive.blocks {
let staged = staging.contains(key);
if !verify_backup && (known.contains(key) || staged) {
continue;
}
let path = block_path(name, manifest.bundle, key);
let store = store.clone();
let bytes = bytes.clone();
let key = *key;
let receipts = &staging;
writes.push(async move {
let needed = if verify_backup && (manifest.bundle_commits > 1 || staged) {
// A healthy primary load does not establish the integrity of its
// independent backup. Check reused bytes and repair only damaged pages.
match timeout(DataUsageCache::cache_save_timeout(), backup_revision(store.as_ref(), &path, &bytes))
.await
.map_err(|_| Error::other("scanner backup page validation timed out"))??
{
Some(revision) => revision,
None => return Ok(()),
}
} else {
DataUsageCacheRevision::Missing
};
DataUsageCache::save_path_with_retry(
store,
&path,
&bytes,
DataUsageCache::cache_save_timeout(),
DATA_USAGE_CACHE_SAVE_RETRIES,
Some(needed),
Some(epoch),
)
.await?;
receipts.record(key);
Ok::<(), Error>(())
});
if writes.len() == IO_CONCURRENCY {
try_join_all(std::mem::take(&mut writes)).await?;
}
}
try_join_all(writes).await?;
Ok(())
}
@@ -1,76 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
use std::any::Any;
use std::sync::{Mutex, Weak};
use std::time::Instant as WallInstant;
/// A manifest commit can be interrupted after any group of immutable PUTs.
/// Reuse only receipts from the same store, epoch and predecessor revision.
struct Attempt {
store: Weak<dyn Any + Send + Sync>,
path: String,
bundle: uuid::Uuid,
epoch: u64,
revision: DataUsageCacheRevision,
seen: Arc<Mutex<HashSet<Digest>>>,
last_used: WallInstant,
}
const MAX_ATTEMPTS: usize = 32;
static ATTEMPTS: LazyLock<Mutex<Vec<Attempt>>> = LazyLock::new(|| Mutex::new(Vec::new()));
pub(super) struct Staging(Arc<Mutex<HashSet<Digest>>>);
impl Staging {
pub(super) fn open<S: ScannerObjectIO>(
store: &Arc<S>,
path: &str,
bundle: uuid::Uuid,
epoch: u64,
revision: &DataUsageCacheRevision,
) -> Self {
let store: Arc<dyn Any + Send + Sync> = store.clone();
let owner = Arc::downgrade(&store);
let mut attempts = ATTEMPTS.lock().unwrap_or_else(|p| p.into_inner());
attempts.retain(|job| job.store.strong_count() != 0 && job.last_used.elapsed() < Duration::from_secs(3600));
if let Some(attempt) = attempts.iter_mut().find(|attempt| {
attempt.store.ptr_eq(&owner)
&& attempt.path == path
&& attempt.bundle == bundle
&& attempt.epoch == epoch
&& &attempt.revision == revision
}) {
attempt.last_used = WallInstant::now();
return Self(attempt.seen.clone());
}
// A successfully committed predecessor naturally retires the receipts
// for its previous ETag. Concurrent older writers retain their own Arc.
attempts.retain(|attempt| !attempt.store.ptr_eq(&owner) || attempt.path != path);
if attempts.len() >= MAX_ATTEMPTS
&& let Some((index, _)) = attempts.iter().enumerate().min_by_key(|(_, job)| job.last_used)
{
attempts.swap_remove(index);
}
let seen = Arc::new(Mutex::new(HashSet::new()));
attempts.push(Attempt {
store: owner,
path: path.to_owned(),
bundle,
epoch,
revision: revision.clone(),
seen: seen.clone(),
last_used: WallInstant::now(),
});
Self(seen)
}
pub(super) fn contains(&self, key: &Digest) -> bool {
self.0.lock().unwrap_or_else(|p| p.into_inner()).contains(key)
}
pub(super) fn record(&self, key: Digest) {
self.0.lock().unwrap_or_else(|p| p.into_inner()).insert(key);
}
}
@@ -1,208 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
use crate::scanner_budget::ScannerCycleBudget;
use std::any::Any;
use std::sync::{Mutex, Weak};
use tokio_util::sync::CancellationToken;
// Keep only a failed root's identity while its independent backup is being
// recovered. A fresh primary reader still obtains the current ETag every time.
pub(super) struct PendingBackup {
owner: Weak<dyn Any + Send + Sync>,
name: String,
failed_etag: String,
last_polled: tokio::time::Instant,
}
static PENDING_BACKUPS: Mutex<Vec<PendingBackup>> = Mutex::new(Vec::new());
const MAX_PENDING_BACKUPS: usize = 32;
// Age permits reclamation under contention. A scanner whose configured
// interval exceeds this age can still resume while slots remain available.
pub(super) fn park_restore<T>(
slots: &mut Vec<T>,
limit: usize,
value: T,
last_polled: impl Fn(&T) -> tokio::time::Instant,
) -> Option<T> {
if slots.len() < limit {
slots.push(value);
return None;
}
if let Some(oldest) = slots.iter_mut().min_by_key(|slot| last_polled(slot))
&& last_polled(oldest).elapsed() >= Duration::from_secs(3600)
{
return Some(std::mem::replace(oldest, value));
}
Some(value)
}
impl PendingBackup {
fn owner<S: ScannerObjectIO>(store: &Arc<S>) -> Weak<dyn Any + Send + Sync> {
let erased: Arc<dyn Any + Send + Sync> = store.clone();
Arc::downgrade(&erased)
}
pub(super) fn needs_backup<S: ScannerObjectIO>(store: &Arc<S>, name: &str, etag: &str) -> bool {
let owner = Self::owner(store);
let mut pending = PENDING_BACKUPS.lock().unwrap_or_else(|error| error.into_inner());
let Some(index) = pending
.iter()
.position(|phase| phase.owner.ptr_eq(&owner) && phase.name == name)
else {
return false;
};
if pending[index].failed_etag == etag {
pending[index].last_polled = tokio::time::Instant::now();
true
} else {
pending.swap_remove(index);
false
}
}
pub(super) fn begin<S: ScannerObjectIO>(store: &Arc<S>, name: &str, etag: &str) {
let owner = Self::owner(store);
let mut pending = PENDING_BACKUPS.lock().unwrap_or_else(|error| error.into_inner());
pending.retain(|phase| phase.owner.strong_count() > 0 && !(phase.owner.ptr_eq(&owner) && phase.name == name));
let phase = Self {
owner,
name: name.to_owned(),
failed_etag: etag.to_owned(),
last_polled: tokio::time::Instant::now(),
};
let _ = park_restore(&mut pending, MAX_PENDING_BACKUPS, phase, |phase| phase.last_polled);
}
pub(super) fn finish<S: ScannerObjectIO>(store: &Arc<S>, name: &str, etag: &str) {
let owner = Self::owner(store);
PENDING_BACKUPS
.lock()
.unwrap_or_else(|error| error.into_inner())
.retain(|phase| !(phase.owner.ptr_eq(&owner) && phase.name == name && phase.failed_etag == etag));
}
}
struct DecodedCheckpoint {
owner: Weak<dyn Any + Send + Sync>,
name: String,
parked_at: std::time::Instant,
cache: DataUsageCache,
revisions: DataUsageCacheRevisions,
}
// The scanner may finish a cold restore with too little time for the walk.
// Move that exact value to the next admission. Only one decoded bucket can
// occupy the handoff and it never owns storage, a permit, or a publication fence.
static DECODED: Mutex<Option<DecodedCheckpoint>> = Mutex::new(None);
impl DataUsageCache {
pub(crate) async fn load_for_scan<S: ScannerObjectIO>(
&mut self,
store: Arc<S>,
name: &str,
ctx: &CancellationToken,
budget: &ScannerCycleBudget,
) -> StorageResult<Option<DataUsageCacheRevisions>> {
tokio::select! {
biased;
_ = ctx.cancelled() => Ok(None),
result = crate::storage_api::ecstore_with_background_disk_io(
ctx.clone(),
self.load_for_scan_window(store, name, budget),
) => result,
}
}
async fn load_for_scan_window<S: ScannerObjectIO>(
&mut self,
store: Arc<S>,
name: &str,
budget: &ScannerCycleBudget,
) -> StorageResult<Option<DataUsageCacheRevisions>> {
let erased: Arc<dyn Any + Send + Sync> = store.clone();
let owner = Arc::downgrade(&erased);
let is_ours = |ready: &DecodedCheckpoint| ready.owner.ptr_eq(&owner) && ready.name == name;
let cached = {
let mut decoded = DECODED.lock().unwrap_or_else(|error| error.into_inner());
// Give a retired or deleted bucket's slot back to other active
// readers. A matching admission can consume it even after a long
// scheduled interval, subject to the revision checks below.
decoded.take_if(|ready| {
ready.owner.strong_count() == 0 || (!is_ours(ready) && ready.parked_at.elapsed() >= Duration::from_secs(3600))
});
decoded.as_ref().is_some_and(is_ours)
};
if cached {
let path = path_join_buf(&[BUCKET_META_PREFIX, name]);
let main = read_config_revision(store.clone(), &path).await;
let backup = Self::backup_revision(store.clone(), name).await;
let ready = DECODED
.lock()
.unwrap_or_else(|error| error.into_inner())
.take_if(|ready| is_ours(ready));
if let (Some(ready), Ok(main)) = (ready, main)
&& ready.revisions.main == main
&& ready.revisions.backup == backup
{
*self = ready.cache;
return Ok(Some(ready.revisions));
}
}
let started = tokio::time::Instant::now();
// Obtain the optional backup head before the expensive decode. A budget
// stop after the decoder finishes must not discard the materialized tree
// while waiting for an unrelated backup lookup.
let backup = Self::backup_revision(store.clone(), name).await;
let loaded = Box::pin(Self::load_cache(store, name)).await?;
let revisions = DataUsageCacheRevisions {
main: loaded.main_revision,
backup: loaded.backup_revision.or(backup),
damaged_pages: loaded.damaged_pages,
};
*self = loaded.cache;
if self.info.scan_identity.is_some()
&& !self.cache.is_empty()
&& budget
.remaining_config()
.max_duration
.is_some_and(|remaining| started.elapsed() > remaining)
{
let mut slot = DECODED.lock().unwrap_or_else(|error| error.into_inner());
if slot.as_ref().is_none_or(|ready| ready.owner.strong_count() == 0) {
*slot = Some(DecodedCheckpoint {
owner,
name: name.to_owned(),
parked_at: std::time::Instant::now(),
cache: std::mem::take(self),
revisions,
});
return Ok(None);
}
}
Ok(Some(revisions))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test(start_paused = true)]
async fn only_reclaim_idle_restore_slots_under_pressure() {
let first = tokio::time::Instant::now();
tokio::time::advance(Duration::from_secs(7200)).await;
let second = tokio::time::Instant::now();
let mut slots = vec![first];
assert_eq!(park_restore(&mut slots, 2, second, |&time| time), None);
assert_eq!(slots, [first, second]);
let new = second + Duration::from_secs(1);
assert_eq!(park_restore(&mut slots, 2, new, |&time| time), Some(first));
assert_eq!(slots, [new, second]);
assert_eq!(park_restore(&mut slots, 2, new, |&time| time), Some(new));
assert_eq!(slots, [new, second], "active recoveries retain both slots");
}
}
@@ -1,133 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
/// A linked tree paused on a different physical replica. It contains only
/// traversal fields, so dormant sources cannot recursively contain each other.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct SourceTree {
bucket: String,
identity: DataUsageScanIdentity,
started_plan: DataUsageScanPlanDigest,
#[serde(serialize_with = "ordered_entries")]
entries: HashMap<String, DataUsageEntry>,
resume_after: Option<String>,
checkpoint: Option<DataUsageScanCheckpoint>,
coverage: Option<DataUsageScanCoverageReceipt>,
cursor: Option<DataUsageRawEnumerationCursor>,
index: Option<RawEnumerationPageIndex>,
ancestors: Vec<RawEnumerationPageIndex>,
}
impl SourceTree {
/// An inactive receipt may preserve an existing source position. Only an
/// active, verified traversal can contribute new progress.
pub(super) fn frontier(&self, info: &DataUsageCacheInfo) -> Option<&str> {
if self.bucket != info.name
|| Some(self.identity) != info.scan_identity
|| Some(self.started_plan) != info.scan_progress.map(|p| p.started_plan)
{
return None;
}
self.coverage.as_ref().map(|receipt| receipt.through.as_str())
}
}
// Dormant trees live in the checkpoint header stream. A cold process has
// fresh HashMap seeds; preserve stable bytes for immutable Merkle pages.
fn ordered_entries<S: serde::Serializer>(
entries: &HashMap<String, DataUsageEntry>,
serializer: S,
) -> std::result::Result<S::Ok, S::Error> {
let mut sorted = entries.iter().collect::<Vec<_>>();
sorted.sort_unstable_by(|a, b| a.0.cmp(b.0));
serializer.collect_map(sorted.into_iter().map(|(name, entry)| (name, entry.ordered_encoding())))
}
impl DataUsageCache {
pub(crate) fn activate_directory_source(&mut self, source: String, endpoints: &HashSet<String>) {
let (Some(identity), Some(progress)) = (self.info.scan_identity, self.info.scan_progress) else {
return;
};
let previous = self.info.scan_directory_source.replace(source.clone());
// Every production endpoint has an erasure-set slot. A disk replacement
// cannot retain a backup under the same slot or under a retired endpoint.
let current_location = directory_source_location(&source);
self.info.scan_directory_work.retain(|work| {
work.endpoint() == source
|| endpoints.contains(directory_source_location(work.endpoint()))
&& directory_source_location(work.endpoint()) != current_location
});
self.info.scan_source_trees.retain(|key, tree| {
tree.bucket == self.info.name
&& tree.identity == identity
&& tree.started_plan == progress.started_plan
&& (key == &source
|| endpoints.contains(directory_source_location(key)) && directory_source_location(key) != current_location)
});
let Some(previous) = previous else {
// Pre-source checkpoints identify an erasure set but never recorded
// which disk supplied the partial tree. The same keys can have
// different metadata on another replica. Keep the certified usage,
// repair obligations and observations outside this traversal.
if self.has_scan_position() {
self.clear_active_directory_traversal();
}
return;
};
if previous == source {
return;
}
let entries = std::mem::take(&mut self.cache);
let linked = entries.get(&hash_path(&self.info.name).0).is_some_and(|root| !root.compacted);
let previous_tree = SourceTree {
bucket: self.info.name.clone(),
identity,
started_plan: progress.started_plan,
entries,
resume_after: self.info.scan_resume_after.take(),
checkpoint: self.info.scan_checkpoint.take(),
coverage: self.info.scan_coverage_receipt.take(),
cursor: self.info.scan_raw_enumeration_cursor.take(),
index: self.info.scan_raw_enumeration_page_index.take(),
ancestors: std::mem::take(&mut self.info.scan_raw_enumeration_path_page_indexes),
};
if linked
&& endpoints.contains(directory_source_location(&previous))
&& directory_source_location(&previous) != current_location
{
self.info.scan_source_trees.insert(previous, Arc::new(previous_tree));
}
if let Some(tree) = self.info.scan_source_trees.remove(&source) {
let tree = Arc::unwrap_or_clone(tree);
self.cache = tree.entries;
self.info.scan_resume_after = tree.resume_after;
self.info.scan_coverage_receipt = tree.coverage;
self.info.scan_checkpoint = tree.checkpoint;
self.info.scan_raw_enumeration_cursor = tree.cursor;
self.info.scan_raw_enumeration_page_index = tree.index;
self.info.scan_raw_enumeration_path_page_indexes = tree.ancestors;
// A dormant tree must provide the same coverage/graph guarantees
// required of an active checkpoint before its child links are used.
if self.checked_flatten_complete_scope(&self.info.name).is_none()
|| self.info.scan_coverage_receipt.is_some() && self.validated_scan_frontier().is_none()
{
self.clear_active_directory_traversal();
}
}
}
fn clear_active_directory_traversal(&mut self) {
self.cache.clear();
self.info.scan_resume_after = None;
self.info.scan_checkpoint = None;
self.info.scan_coverage_receipt = None;
self.info.scan_raw_enumeration_cursor = None;
self.info.scan_raw_enumeration_page_index = None;
self.info.scan_raw_enumeration_path_page_indexes.clear();
}
}
fn directory_source_location(source: &str) -> &str {
source.split_once('|').map_or(source, |(_, endpoint)| endpoint)
}
@@ -653,7 +653,6 @@ async fn cache_save_reconciles_an_ambiguous_committed_write() {
cache.replace("bucket", "", DataUsageEntry::default());
let revisions = DataUsageCacheRevisions {
main: DataUsageCacheRevision::Missing,
damaged_pages: DamagedPages::default(),
backup: None,
};
@@ -2858,7 +2857,6 @@ async fn test_save_backup_budget_tracks_primary_cost() {
let store = Arc::new(store);
let revisions = DataUsageCacheRevisions {
main: DataUsageCacheRevision::Missing,
damaged_pages: DamagedPages::default(),
backup: Some(DataUsageCacheRevision::Etag("backup-etag".to_string())),
};
DataUsageCache::default()
@@ -2911,7 +2909,6 @@ async fn test_checkpoint_budget_covers_retries_and_reconciliation() {
let store = Arc::new(store);
let revisions = DataUsageCacheRevisions {
main: DataUsageCacheRevision::Missing,
damaged_pages: DamagedPages::default(),
backup: Some(DataUsageCacheRevision::Etag("backup-etag".to_string())),
};
let started = Instant::now();
@@ -88,7 +88,6 @@ async fn check_save(store: BackupFallbackStore, revisions: Option<DataUsageCache
fn revisions(backup: bool) -> DataUsageCacheRevisions {
DataUsageCacheRevisions {
main: DataUsageCacheRevision::Missing,
damaged_pages: DamagedPages::default(),
backup: backup.then_some(DataUsageCacheRevision::Missing),
}
}
+16 -11
View File
@@ -15,7 +15,6 @@
use crate::data_usage_define::clone_cache_value;
use serde::{Deserialize, Serialize};
use sha2::{Digest as _, Sha256};
use std::sync::Arc;
use thiserror::Error;
mod writer;
@@ -59,7 +58,7 @@ pub struct RawEnumerationPage {
parent: String,
page_index: u64,
entries_start: u64,
entries: Arc<[String]>,
entries: Vec<String>,
terminal: bool,
digest: [u8; 32],
}
@@ -519,26 +518,32 @@ impl RawEnumerationPage {
}
fn new(parent: &str, building: RawEnumerationPageBuilder) -> Self {
let digest = raw_page_digest(parent, building.page_index, building.entries_start, building.terminal, &building.entries);
let digest = raw_page_digest(parent, &building);
Self {
version: RAW_PAGE_INDEX_VERSION,
parent: clone_cache_value(parent),
page_index: building.page_index,
entries_start: building.entries_start,
entries: building.entries.into(),
entries: building.entries,
terminal: building.terminal,
digest,
}
}
fn validate(&self, parent: &str, page_index: u64, entries_start: u64) -> Result<(), RawEnumerationPageIndexError> {
let builder = RawEnumerationPageBuilder {
page_index: self.page_index,
entries_start: self.entries_start,
entries: clone_cache_value(&self.entries),
terminal: self.terminal,
};
if self.version != RAW_PAGE_INDEX_VERSION
|| self.parent != parent
|| self.page_index != page_index
|| self.entries_start != entries_start
|| self.entries.is_empty()
|| !entries_are_normalized(&self.entries)
|| self.digest != raw_page_digest(parent, self.page_index, self.entries_start, self.terminal, &self.entries)
|| self.digest != raw_page_digest(parent, &builder)
{
return Err(RawEnumerationPageIndexError::CorruptIndex);
}
@@ -582,16 +587,16 @@ fn entry_sets_match(left: &[String], right: &[String]) -> bool {
left.len() == right.len() && entries_contain_all(left, right)
}
fn raw_page_digest(parent: &str, page_index: u64, entries_start: u64, terminal: bool, entries: &[String]) -> [u8; 32] {
fn raw_page_digest(parent: &str, building: &RawEnumerationPageBuilder) -> [u8; 32] {
#[cfg(test)]
RAW_PAGE_DIGEST_ENTRIES.with(|count| count.set(count.get().saturating_add(entries.len())));
RAW_PAGE_DIGEST_ENTRIES.with(|count| count.set(count.get().saturating_add(building.entries.len())));
let mut digest = Sha256::new();
update_digest(&mut digest, b"version", &RAW_PAGE_INDEX_VERSION.to_le_bytes());
update_digest(&mut digest, b"parent", parent.as_bytes());
update_digest(&mut digest, b"page_index", &page_index.to_le_bytes());
update_digest(&mut digest, b"entries_start", &entries_start.to_le_bytes());
update_digest(&mut digest, b"terminal", &[u8::from(terminal)]);
for entry in entries {
update_digest(&mut digest, b"page_index", &building.page_index.to_le_bytes());
update_digest(&mut digest, b"entries_start", &building.entries_start.to_le_bytes());
update_digest(&mut digest, b"terminal", &[u8::from(building.terminal)]);
for entry in &building.entries {
update_digest(&mut digest, b"entry", entry.as_bytes());
}
digest.finalize().into()
@@ -64,15 +64,6 @@ impl RawEnumerationPageWriter {
})
}
/// A parked native stream delivers the unread tail first. Incomplete
/// membership can immediately append that tail; terminal page verification
/// still requires observing the entire current directory.
pub(crate) fn continue_native_stream(&mut self) {
if !self.inner.complete && !self.inner.building.as_ref().is_some_and(|page| page.terminal) {
self.observations = self.revalidate_after_entries;
}
}
pub(crate) fn indexed_entry_count(&self) -> usize {
self.indexed.len()
}
+3 -8
View File
@@ -963,14 +963,9 @@ async fn scan_and_persist_local_bucket_with_store(
}
})?;
let mut cache = DataUsageCache::default();
let Some(mut revisions) = Box::pin(cache.load_for_scan(set.clone(), &cache_name, &ctx, &budget))
.await
.map_err(|err| {
RemoteScannerServerError::worker(format!("remote namespace scanner cache load or revision lookup failed: {err}"))
})?
else {
return Ok(RemoteScannerFrameResult::Partial);
};
let mut revisions = cache.load_with_revisions(set.clone(), &cache_name).await.map_err(|err| {
RemoteScannerServerError::worker(format!("remote namespace scanner cache load or revision lookup failed: {err}"))
})?;
let expected_incarnation = cache
.info
.scan_identity
@@ -1198,43 +1198,6 @@ async fn terminal_frame_without_eof_still_obeys_semantic_stall_timeout() {
assert!(error.to_string().contains("no semantic progress"));
}
#[tokio::test(start_paused = true)]
async fn heartbeat_frames_without_discovery_do_not_extend_semantic_deadline() {
let request_id = Uuid::new_v4();
let writer_auth = FrameAuthenticator::for_test(request_id);
let reader_auth = FrameAuthenticator::for_test(request_id);
let (mut writer, reader) = tokio::io::duplex(4096);
let heartbeats = tokio::spawn(async move {
let mut sequence = 0;
loop {
write_frame(
&mut writer,
&writer_auth,
&mut sequence,
&RemoteScannerFrame::with_phase(
RemoteScannerProgress::default(),
RemoteScannerPhase::Scanning,
RemoteScannerFrameResult::Progress,
),
)
.await
.expect("deliver authenticated heartbeat");
writer.flush().await.expect("flush heartbeat");
tokio::time::sleep(Duration::from_secs(4)).await;
}
});
let owner = CancellationToken::new();
let budget = ScannerCycleBudget::new(&owner, ScannerCycleBudgetConfig::default());
let started = Instant::now();
let error = consume_remote_scanner_stream(reader, owner, budget, "bucket", TEST_SOURCE, TEST_PLAN_DIGEST, reader_auth)
.await
.expect_err("heartbeats without work cannot keep the scanner alive");
assert!(error.to_string().contains("no semantic progress"));
assert_eq!(started.elapsed(), NS_SCANNER_SEMANTIC_STALL_TIMEOUT);
heartbeats.abort();
let _ = heartbeats.await;
}
struct ResetAfterFrame {
bytes: Vec<u8>,
position: usize,
+30 -113
View File
@@ -34,9 +34,8 @@ use crate::runtime_config::{
use crate::scanner_budget::{ScannerCycleBudget, ScannerCycleBudgetConfig, ScannerCycleBudgetReason};
use crate::scanner_folder::{data_usage_update_dir_cycles, heal_object_select_prob};
use crate::scanner_io::{
ScannerCycleDeferReason, ScannerCycleResult, ScannerCycleStatus, ScannerServiceCohort, dirty_usage_bucket_notified,
dirty_usage_buckets_pending, dirty_usage_generation, scanner_dirty_usage_state, scanner_maintenance_changed,
scanner_maintenance_generation,
ScannerCycleDeferReason, ScannerCycleResult, ScannerCycleStatus, dirty_usage_bucket_notified, dirty_usage_buckets_pending,
dirty_usage_generation, scanner_dirty_usage_state, scanner_maintenance_changed, scanner_maintenance_generation,
};
use crate::sleeper::{SCANNER_SLEEPER, set_scanner_default_speed};
use crate::{DataUsageInfo, ScannerActivityGuard, ScannerError, ScannerRuntimeGuard};
@@ -56,7 +55,7 @@ use rustfs_lock::{NamespaceLockGuard, error::LockError};
use rustfs_scanner_metrics::metrics::{
CurrentCycle, Metric, Metrics, RemoteScanProgress, ScanCyclePartialReason, ScanCycleWorkSnapshot,
ScannerUsagePublicationObservation, ScannerUsageSaveResult, ScannerWorkSource, emit_scan_cycle_complete,
emit_scan_cycle_deferred, emit_scan_cycle_partial_with_stage, emit_scan_cycle_superseded, global_metrics,
emit_scan_cycle_deferred, emit_scan_cycle_partial_with_source, emit_scan_cycle_superseded, global_metrics,
};
use rustfs_scanner_metrics::startup::ScannerStartupToken;
use serde::{Deserialize, Serialize};
@@ -1213,8 +1212,6 @@ where
}
let mut transient_backoff = ScannerRetryBackoff::default();
// Only this supervisor, for this storage instance, owns resumable service.
let mut service_continuation = None;
let mut recovery_retry_count = 0_u32;
loop {
if ctx_clone.is_cancelled() {
@@ -1229,7 +1226,6 @@ where
startup_features,
startup_maintenance_generation,
startup,
&mut service_continuation,
)
.await;
if let Err(e) = &run_result {
@@ -1777,26 +1773,11 @@ where
}
}
/// Scheduling and mutation witnesses retained across a clean local deadline.
/// Only an immediately succeeding leadership claim can resume this cohort.
struct ScannerServiceContinuation {
cohort: Arc<StdMutex<ScannerServiceCohort>>,
fenced_epoch: u64,
fenced_revision: DataUsageCacheRevision,
}
impl ScannerServiceContinuation {
fn matches_claim(&self, previous_revision: &DataUsageCacheRevision, claimed_epoch: u64) -> bool {
&self.fenced_revision == previous_revision && self.fenced_epoch.checked_add(1) == Some(claimed_epoch)
}
}
struct ScannerCycleDeadlineState<'a> {
cycle_info: &'a mut CurrentCycle,
cycle_revision: &'a mut DataUsageCacheRevision,
leader_epoch: &'a mut u64,
cycle_budget: &'a ScannerCycleBudget,
service_cohort: Arc<StdMutex<ScannerServiceCohort>>,
allow_bootstrap_pending: bool,
}
@@ -1810,8 +1791,7 @@ async fn handle_scanner_cycle_deadline<Store>(
state: ScannerCycleDeadlineState<'_>,
worker_stopped: bool,
guard: &mut NamespaceLockGuard,
) -> Option<ScannerServiceContinuation>
where
) where
Store: ScannerObjectIO + ScannerConfigObjectDelete,
{
let fenced = fence_scanner_epoch_after_cycle_timeout(
@@ -1841,14 +1821,8 @@ where
global_metrics().record_scanner_cycle_timeout(recovery_required, state.cycle_budget.progress_age());
// Stop renewing before releasing the lease. A new leader can then claim the
// higher persisted generation instead of inheriting the expired worker.
let may_resume = !recovery_required && !guard.is_lock_lost() && !ctx.is_cancelled();
guard.release();
global_metrics().set_cycle(None).await;
may_resume.then(|| ScannerServiceContinuation {
cohort: state.service_cohort,
fenced_epoch: *state.leader_epoch,
fenced_revision: state.cycle_revision.clone(),
})
}
async fn mark_scan_cycle_idle(cycle_info: &mut CurrentCycle, cycle_metrics_guard: &mut ScannerCycleMetricsGuard) {
@@ -2486,20 +2460,13 @@ where
event = EVENT_SCANNER_CYCLE_STATE,
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_RUNTIME,
state = "cache_cycle_ahead",
partial_stage = "cache_cycle_ahead",
cycle = cycle_info.current,
leader_epoch,
required_cycle,
state = "cache_cycle_ahead",
partial_cause = "cache_cycle_ahead",
"Scanner cycle is recovering to a newer durable cache generation"
);
let partial = emit_scan_cycle_partial_with_stage(
cycle_start.elapsed(),
ScanCyclePartialReason::Unknown,
None,
Some("cache_cycle_ahead"),
);
emit_scan_cycle_partial_with_source(cycle_start.elapsed(), ScanCyclePartialReason::Unknown, None);
let persisted = persist_required_scanner_cycle_floor_for_epoch(
ctx,
storeapi.clone(),
@@ -2513,7 +2480,6 @@ where
},
)
.await;
partial.observe_state_write(persisted);
return if persisted {
cycle_budget.mark_cycle_state_persisted();
ScannerCycleOutcome::Partial
@@ -2564,7 +2530,18 @@ where
}
usage_publication_result.restrict_outcome(usage_persist_outcome);
let (partial_cause, partial_stage) = partial_cycle_diagnostic(&scan_cycle_result);
let partial_cause = if scan_cycle_result.has_partial_bucket_progress() && !scan_cycle_result.has_usage_update() {
"saved_bucket_progress"
} else if scan_cycle_result.has_usage_update()
&& matches!(
scan_cycle_result.status,
ScannerCycleStatus::Deferred(ScannerCycleDeferReason::ActivityBaselineUnavailable)
)
{
"activity_unverified_observation"
} else {
"incomplete_coverage"
};
#[cfg(feature = "e2e-test-hooks")]
let durable_observation = scan_cycle_result
.publication_expectation()
@@ -2643,35 +2620,25 @@ where
);
}
if cycle_budget.budget_elapsed() {
let budget_reason = cycle_budget.reason();
let budget_stage = match budget_reason {
Some(ScannerCycleBudgetReason::Runtime) => Some("runtime_budget"),
Some(ScannerCycleBudgetReason::Objects) => Some("object_budget"),
Some(ScannerCycleBudgetReason::Directories) => Some("directory_budget"),
Some(ScannerCycleBudgetReason::Entries) => Some("entry_budget"),
None => None,
};
warn!(
target: "rustfs::scanner",
event = EVENT_SCANNER_CYCLE_STATE,
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_RUNTIME,
state = "budget_reached",
partial_stage = budget_stage,
cycle = cycle_info.current,
leader_epoch,
duration = ?now.elapsed(),
reason = ?budget_reason,
reason = ?cycle_budget.reason(),
max_duration = ?cycle_budget.max_duration(),
max_objects = ?cycle_budget.max_objects(),
max_directories = ?cycle_budget.max_directories(),
state = "budget_reached",
"Scanner cycle budget reached"
);
let partial = emit_scan_cycle_partial_with_stage(
let budget_reason = cycle_budget.reason();
emit_scan_cycle_partial_with_source(
cycle_start.elapsed(),
scan_cycle_partial_reason(budget_reason),
scan_cycle_partial_source(budget_reason),
budget_stage,
);
let persisted = finalize_partial_scan_cycle_for_epoch(
ctx,
@@ -2683,7 +2650,6 @@ where
publication_epoch,
)
.await;
partial.observe_state_write(persisted);
return if persisted {
cycle_budget.mark_cycle_state_persisted();
ScannerCycleOutcome::Partial
@@ -2717,56 +2683,29 @@ where
return ScannerCycleOutcome::Failed;
}
ScannerCycleOutcome::Partial => {
let owner_cancelled = ctx.is_cancelled();
let partial_stage = if owner_cancelled { "owner_cancelled" } else { partial_stage };
if owner_cancelled {
if ctx.is_cancelled() {
debug!(
target: "rustfs::scanner",
event = EVENT_SCANNER_CYCLE_STATE,
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_RUNTIME,
state = "incomplete_cancelled",
cycle = cycle_info.current,
leader_epoch,
partial_stage,
state = "incomplete_cancelled",
"Scanner cycle stopped before a complete usage snapshot was produced"
);
} else if partial_cause == "saved_bucket_progress"
&& matches!(partial_stage, "bucket_checkpoint_saved" | "bucket_walk_incomplete")
{
} else {
warn!(
target: "rustfs::scanner",
event = EVENT_SCANNER_CYCLE_STATE,
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_RUNTIME,
state = "incomplete",
cycle = cycle_info.current,
leader_epoch,
partial_cause,
partial_stage,
"Scanner saved bucket progress before completing coverage"
);
} else {
error!(
target: "rustfs::scanner",
event = EVENT_SCANNER_CYCLE_STATE,
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_RUNTIME,
state = "incomplete",
cycle = cycle_info.current,
leader_epoch,
partial_cause,
partial_stage,
persist_outcome = ?usage_persist_outcome,
"Scanner cycle could not certify complete usage"
"Scanner cycle ended without a complete usage snapshot"
);
}
let partial = emit_scan_cycle_partial_with_stage(
cycle_start.elapsed(),
ScanCyclePartialReason::Unknown,
None,
Some(partial_stage),
);
emit_scan_cycle_partial_with_source(cycle_start.elapsed(), ScanCyclePartialReason::Unknown, None);
let persisted = finalize_partial_scan_cycle_for_epoch(
ctx,
storeapi.clone(),
@@ -2777,7 +2716,6 @@ where
publication_epoch,
)
.await;
partial.observe_state_write(persisted);
return if persisted {
cycle_budget.mark_cycle_state_persisted();
ScannerCycleOutcome::Partial
@@ -2971,7 +2909,6 @@ where
maintenance_features,
maintenance_generation,
runtime_guard.startup_token(),
&mut None,
)
.await
}
@@ -3058,12 +2995,10 @@ async fn run_data_scanner_with_maintenance_state<S>(
mut maintenance_features: ScannerMaintenanceFeatures,
mut maintenance_generation_seen: Option<u64>,
startup: ScannerStartupToken,
continuation: &mut Option<ScannerServiceContinuation>,
) -> Result<(), ScannerError>
where
S: ScannerStorage,
{
let previous = continuation.take();
reset_scanner_cycle_schedule();
// Normal scanner entry is an attempt, not evidence of leadership, coverage, or publication.
global_metrics().startup().record_attempt(startup);
@@ -3173,6 +3108,7 @@ where
let mut deferred_backoff = ScannerRetryBackoff::default();
let mut scope_fallback_backoff = ScannerRetryBackoff::default();
let scope_fallback_slot = Arc::new(ScannerScopeFallbackSlot::default());
let service_cohort = Arc::new(StdMutex::new(crate::scanner_io::ScannerServiceCohort::default()));
let initial_runtime_config = resolve_scanner_runtime_config();
if clean_idle_topology_supported && maintenance_generation_seen.is_none() {
let Some((features, generation)) = detect_stable_scanner_maintenance_features(&ctx, &storeapi).await else {
@@ -3333,7 +3269,6 @@ where
finish_scanner_leader_iteration(guard.is_lock_lost(), "stopped", String::new()).await;
return Ok(());
}
let previous_revision = cycle_revision.clone();
let claim_ctx = ctx.child_token();
let leadership_claimed = await_scanner_cycle_with_lock_fence(
&claim_ctx,
@@ -3383,10 +3318,6 @@ where
finish_scanner_leader_iteration(false, "epoch_claim_failed", "leadership epoch claim failed".to_string()).await;
return Ok(());
}
let service_cohort = previous
.filter(|previous| previous.matches_claim(&previous_revision, leader_epoch))
.map(|previous| previous.cohort)
.unwrap_or_default();
if rebuild_from_quarantine {
record_scanner_cycle_state_rebuilt_from_quarantine(cycle_info.next, leader_epoch);
}
@@ -3471,7 +3402,7 @@ where
return Ok(());
}
ScannerCycleWaitOutcome::Deadline { worker_stopped } => {
*continuation = handle_scanner_cycle_deadline(
handle_scanner_cycle_deadline(
&ctx,
storeapi.clone(),
ScannerCycleDeadlineState {
@@ -3479,7 +3410,6 @@ where
cycle_revision: &mut cycle_revision,
leader_epoch: &mut leader_epoch,
cycle_budget: &cycle_budget,
service_cohort,
allow_bootstrap_pending: allow_usage_floor_bootstrap_pending,
},
worker_stopped,
@@ -3817,7 +3747,7 @@ where
return Ok(());
}
ScannerCycleWaitOutcome::Deadline { worker_stopped } => {
*continuation = handle_scanner_cycle_deadline(
handle_scanner_cycle_deadline(
&ctx,
storeapi.clone(),
ScannerCycleDeadlineState {
@@ -3825,7 +3755,6 @@ where
cycle_revision: &mut cycle_revision,
leader_epoch: &mut leader_epoch,
cycle_budget: &cycle_budget,
service_cohort,
allow_bootstrap_pending: allow_usage_floor_bootstrap_pending,
},
worker_stopped,
@@ -4405,18 +4334,6 @@ fn finalize_scanner_cycle_result(
)
}
fn partial_cycle_diagnostic(scan: &crate::scanner_io::ScannerCycleResult) -> (&'static str, &'static str) {
if scan.has_partial_bucket_progress() && !scan.has_usage_update() {
("saved_bucket_progress", scan.partial_stage.unwrap_or("bucket_checkpoint_saved"))
} else if scan.has_usage_update()
&& scan.status == ScannerCycleStatus::Deferred(ScannerCycleDeferReason::ActivityBaselineUnavailable)
{
("activity_unverified_observation", "activity_baseline_unverified")
} else {
("incomplete_coverage", scan.partial_stage.unwrap_or("root_coverage_incomplete"))
}
}
fn scanner_cycle_completion_outcome_for_result(
scan_cycle_result: &crate::scanner_io::ScannerCycleResult,
usage_persist_outcome: DataUsagePersistOutcome,
+2 -39
View File
@@ -52,11 +52,9 @@ const TEST_DEFAULT_SCANNER_CYCLE_SECS: u64 = 24 * 60 * 60;
mod cycle_budget_publication;
pub(super) mod cycle_persist_failure;
mod gate_self_heal;
mod paged_checkpoint;
mod quota_reset_preservation;
mod recovery_control;
mod restore_deadline;
mod scoped_ack_publication;
mod wakeup_metrics;
@@ -775,8 +773,7 @@ async fn cycle_budget_deadline_handler_fences_and_releases_guard() {
);
budget.mark_cycle_state_persisted();
let service_cohort = Arc::new(StdMutex::new(ScannerServiceCohort::default()));
let continuation = handle_scanner_cycle_deadline(
handle_scanner_cycle_deadline(
&ctx,
store.clone(),
ScannerCycleDeadlineState {
@@ -784,24 +781,12 @@ async fn cycle_budget_deadline_handler_fences_and_releases_guard() {
cycle_revision: &mut cycle_revision,
leader_epoch: &mut leader_epoch,
cycle_budget: &budget,
service_cohort: service_cohort.clone(),
allow_bootstrap_pending: false,
},
true,
&mut guard,
)
.await
.expect("a fully drained and fenced deadline retains the live cohort across supervisor iterations");
assert!(Arc::ptr_eq(&continuation.cohort, &service_cohort));
assert!(continuation.matches_claim(&cycle_revision, 3));
assert!(
!continuation.matches_claim(&cycle_revision, 4),
"an intervening owner ends the continuation"
);
assert!(
!continuation.matches_claim(&DataUsageCacheRevision::Missing, 3),
"a replaced cursor ends the continuation"
);
.await;
assert!(guard.is_released());
assert_eq!(leader_epoch, 2, "deadline handler should claim the next epoch");
@@ -1004,7 +989,6 @@ struct MemoryConfigStore {
insert_after_gets: Mutex<HashMap<String, Vec<u8>>>,
read_errors: Mutex<HashMap<String, EcstoreError>>,
delayed_gets: Mutex<HashMap<String, Duration>>,
checkpoint_page_delay_ms: AtomicUsize,
non_regular_objects: Mutex<HashSet<String>>,
fail_put_number: Mutex<HashMap<String, usize>>,
/// Fail every put whose number is at least the stored value.
@@ -1016,7 +1000,6 @@ struct MemoryConfigStore {
cancel_after_successful_puts: Mutex<HashMap<String, (usize, CancellationToken)>>,
replace_after_successful_puts: Mutex<HashMap<String, (usize, Vec<u8>)>>,
error_after_commit_deletes: Mutex<HashSet<String>>,
fail_prefix_deletes: AtomicBool,
cancel_after_deletes: Mutex<HashMap<String, CancellationToken>>,
pause_next_publication_admission: Mutex<Option<(Arc<tokio::sync::Notify>, Arc<tokio::sync::Notify>)>>,
put_counts: Mutex<HashMap<String, usize>>,
@@ -1063,17 +1046,6 @@ impl crate::storage_api::scanner_io::ObjectIO for MemoryConfigStore {
.await
.push(crate::storage_api::ecstore_diagnostic::current_read_version_entry_source());
let key = memory_config_key(bucket, object);
let _serial_page_read = if object.contains(".pages/") {
restore_deadline::admit_page(object).await
} else {
None
};
if object.contains(".pages/") {
let delay = self.checkpoint_page_delay_ms.load(Ordering::Relaxed);
if delay != 0 {
tokio::time::sleep(Duration::from_millis(delay as u64)).await;
}
}
if let Some(error) = self.read_errors.lock().await.get(&key).cloned() {
return Err(error);
}
@@ -5031,15 +5003,6 @@ impl crate::ScannerConfigObjectDelete for MemoryConfigStore {
async fn delete_config_object(&self, bucket: &str, object: &str, opts: ObjectOptions) -> EcstoreResult<ObjectInfo> {
let key = memory_config_key(bucket, object);
let mut objects = self.objects.lock().await;
if opts.delete_prefix && !opts.delete_prefix_object {
if self.fail_prefix_deletes.load(Ordering::Relaxed) {
return Err(EcstoreError::other("injected prefix deletion failure"));
}
assert!(opts.http_preconditions.is_none(), "fixture prefix deletion cannot condition one object");
objects.retain(|object, _| !object.starts_with(&key));
self.revisions.lock().await.retain(|object, _| !object.starts_with(&key));
return Ok(ObjectInfo::default());
}
if !objects.contains_key(&key) {
return Err(EcstoreError::FileNotFound);
}
@@ -253,9 +253,6 @@ async fn assert_coordinator_partial_progress(resume_mixed_plan: bool, fail_cycle
.await;
assert!(matches!(outcome, ScannerCycleOutcome::Partial));
assert_eq!(budget.reason(), Some(ScannerCycleBudgetReason::Objects));
let report = global_metrics().report().await;
assert_eq!(report.last_cycle_partial_reason, "objects");
assert_eq!(report.last_cycle_partial_stage.as_deref(), Some("object_budget"));
assert!(budget.progress().0 > 0);
assert!(budget.cycle_state_persisted());
assert_eq!(cycle.next, 353);
@@ -413,16 +410,6 @@ async fn assert_coordinator_partial_progress(resume_mixed_plan: bool, fail_cycle
super::cycle_persist_failure::fail_saves(1, false, SCANNER_PERSIST_CAS_RETRIES + 1)
}
});
use tracing::instrument::WithSubscriber as _;
let error_log = tempfile::NamedTempFile::new().expect("error log");
let subscriber = tracing_subscriber::fmt()
.json()
.without_time()
.with_ansi(false)
.with_max_level(tracing::Level::ERROR)
.with_writer(error_log.reopen().expect("error log writer"))
.finish();
let _interest_guard = tracing::Dispatch::new(tracing::subscriber::NoSubscriber::default());
let tail_outcome = run_data_scanner_cycle_with_budget(
&ctx,
&store,
@@ -436,23 +423,7 @@ async fn assert_coordinator_partial_progress(resume_mixed_plan: bool, fail_cycle
scope_fallback: None,
},
)
.with_subscriber(subscriber)
.await;
let error_events = std::fs::read_to_string(error_log.path()).expect("read error log");
let event = error_events
.lines()
.map(|line| serde_json::from_str::<serde_json::Value>(line).expect("JSON error event"))
.find(|event| event["fields"]["state"] == "incomplete" && event["fields"]["cycle"] == 353)
.expect("unbudgeted incomplete observation should be visible at error level");
assert_eq!(event["fields"]["leader_epoch"], 1);
assert_eq!(event["fields"]["partial_stage"], "mixed_plan_recertification_pending");
let report = global_metrics().report().await;
assert_eq!(report.last_cycle_partial_reason, "unknown");
if fail_cycle_save == Some(false) {
assert_eq!(report.last_cycle_partial_stage.as_deref(), Some("cycle_state_not_durable"));
} else {
assert_eq!(report.last_cycle_partial_stage.as_deref(), Some("mixed_plan_recertification_pending"));
}
assert!(!tail_budget.budget_elapsed(), "this is not the budget-exhaustion fast path");
checkpoint.load(set, &cache_name).await.expect("reload the saved mixed tail");
assert!(!checkpoint.info.snapshot_complete);
@@ -556,22 +527,6 @@ async fn assert_coordinator_partial_progress(resume_mixed_plan: bool, fail_cycle
crate::scanner_io::clear_dirty_usage_buckets_for_tests();
}
#[test]
fn partial_diagnostics_keep_the_activity_fence_distinct_from_checkpoint_progress() {
let observation =
ScannerCycleResult::new(ScannerCycleStatus::Deferred(ScannerCycleDeferReason::ActivityBaselineUnavailable), None)
.with_usage_update_emitted(true);
assert_eq!(
partial_cycle_diagnostic(&observation),
("activity_unverified_observation", "activity_baseline_unverified")
);
let checkpoint = ScannerCycleResult::new(ScannerCycleStatus::Incomplete, None).with_partial_bucket_progress(true);
assert_eq!(
partial_cycle_diagnostic(&checkpoint),
("saved_bucket_progress", "bucket_checkpoint_saved")
);
}
#[test]
fn partial_progress_does_not_mask_missing_updates_or_persistence_failure() {
for (persisted, expected) in [
@@ -1,475 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
use crate::BUCKET_META_PREFIX;
mod save_review;
const NAME: &str = "bucket/.usage-cache.bin";
fn empty_bucket_checkpoint() -> DataUsageCache {
let mut cache = DataUsageCache::default();
cache.info.name = "bucket".into();
cache.info.source = Some(DataUsageCacheSource::new(0, 0));
cache.info.scan_identity = Some(crate::data_usage_define::DataUsageScanIdentity {
version: crate::data_usage_define::DATA_USAGE_SCAN_CHECKPOINT_VERSION,
bucket_incarnation: uuid::Uuid::from_u128(42),
set_layout: DataUsageScanPlanDigest([7; 32]),
publication_epoch: 0,
tier_registry_generation: 1,
scan_mode: HealScanMode::Normal,
});
cache.replace("bucket", "", DataUsageEntry::default());
cache
}
fn seeded() -> DataUsageCache {
let mut cache = empty_bucket_checkpoint();
for index in 0..4096 {
cache.replace(
&format!("bucket/prefix-{index:05}"),
"bucket",
DataUsageEntry {
size: index + 1,
objects: 1,
versions: 1,
..Default::default()
},
);
}
cache
}
async fn layout(store: &MemoryConfigStore) -> HashMap<String, (usize, usize)> {
let puts = store.put_counts.lock().await.clone();
store
.objects
.lock()
.await
.iter()
.map(|(k, v)| (k.clone(), (puts[k], v.len())))
.collect()
}
fn page_bytes_after_save(before: &HashMap<String, (usize, usize)>, after: &HashMap<String, (usize, usize)>) -> (usize, usize) {
let mut existing = 0;
let mut uploaded = 0;
for (path, &(writes, size)) in after.iter().filter(|(path, _)| path.contains(".pages/")) {
if let Some(&(previous_writes, _)) = before.get(path) {
assert_eq!(writes, previous_writes, "a committed immutable page was resubmitted");
existing += size;
} else {
uploaded += size;
}
}
(existing, uploaded)
}
#[tokio::test]
async fn compacted_checkpoint_advances_one_child_without_rewriting_300k_names() {
let store = Arc::new(MemoryConfigStore::default());
let mut cache = empty_bucket_checkpoint();
let plan = DataUsageScanPlanDigest([1; 32]);
cache.info.scan_progress = Some(crate::DataUsageScanProgress {
started_plan: plan,
requested_plan: plan,
});
cache.info.scan_directory_source = Some(format!("{}|disk-a", uuid::Uuid::from_u128(1)));
let [first, second] = crate::scanner_folder::DirectoryCheckpoint::wide_storage_fixture(&cache.info).await;
let mut before: Option<HashMap<String, (usize, usize)>> = None;
let mut prior_progress = None;
for (objects, receipt) in [(121_034, first), (121_035, second)] {
cache.info.scan_directory_work = vec![receipt];
cache.replace(
"bucket",
"",
DataUsageEntry {
compacted: true,
objects,
size: objects * 1024,
..Default::default()
},
);
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("current revisions");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("save compacted receipt");
let after = layout(&store).await;
if let Some(before) = before.as_ref() {
let (old_bytes, new_bytes) = page_bytes_after_save(before, &after);
eprintln!("300k-name checkpoint: {new_bytes} bytes in new pages, {old_bytes} bytes in existing pages");
assert!(old_bytes > 3_000_000, "fixture must contain the full physical listing");
assert!(
new_bytes > 0 && new_bytes < old_bytes / 10,
"one more completed child wrote {new_bytes} bytes alongside {old_bytes} reused bytes"
);
}
before = Some(after);
let mut restored = DataUsageCache::default();
restored
.load(store.clone(), NAME)
.await
.expect("cold read of compacted receipt");
assert!(restored.info.scan_directory_work[0].is_bound_to(&restored.info));
let progress = restored.durable_scan_progress();
if let Some(prior) = &prior_progress {
assert!(progress.advanced_from(prior), "the new child must earn another durable work turn");
}
prior_progress = Some(progress);
let total = restored.checked_flatten("bucket").expect("connected root after restore");
assert_eq!((total.objects, total.size), (objects, objects * 1024));
cache = restored;
}
}
#[tokio::test]
async fn dormant_linked_tree_pages_survive_source_switch_and_cold_reencoding() {
let store = Arc::new(MemoryConfigStore::default());
let mut cache = seeded();
let plan = DataUsageScanPlanDigest([1; 32]);
cache.info.scan_progress = Some(crate::DataUsageScanProgress {
started_plan: plan,
requested_plan: plan,
});
let endpoints = std::collections::HashSet::from(["disk-a".to_owned(), "disk-b".to_owned()]);
let a = format!("{}|disk-a", uuid::Uuid::from_u128(1));
let b = format!("{}|disk-b", uuid::Uuid::from_u128(2));
cache.info.scan_directory_source = Some(a.clone());
cache.activate_directory_source(b.clone(), &endpoints);
cache.replace("bucket", "", DataUsageEntry::default());
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("before first checkpoint");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("persist dormant linked tree");
let previous = layout(&store).await;
let mut cold = DataUsageCache::default();
cold.load(store.clone(), NAME)
.await
.expect("restore checkpoint in a new process");
cold.activate_directory_source(a, &endpoints);
assert_eq!(cold.checked_flatten("bucket").expect("first source entries").objects, 4096);
cold.activate_directory_source(b, &endpoints);
assert_eq!(cold.checked_flatten("bucket").expect("second source root").objects, 0);
cold.replace(
"bucket/new-key",
"bucket",
DataUsageEntry {
objects: 1,
size: 99,
..Default::default()
},
);
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("before second checkpoint");
cold.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("save one new child");
let after = layout(&store).await;
let (prior_bytes, new_bytes) = page_bytes_after_save(&previous, &after);
assert!(prior_bytes > 128 * 1024);
assert!(
new_bytes > 0 && new_bytes < prior_bytes / 8,
"dormant tree rewritten: {new_bytes} new bytes for {prior_bytes} prior bytes"
);
}
#[tokio::test]
async fn paged_checkpoint_writes_only_changed_pages_and_commits_root_last() {
let store = Arc::new(MemoryConfigStore::default());
let cache = seeded();
let first = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("empty revisions");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &first, 0, CancellationToken::new())
.await
.expect("initial checkpoint");
let before = layout(&store).await;
let encoded = cache.marshal_msg().expect("encode baseline").len();
let main = memory_config_key(RUSTFS_META_BUCKET, &format!("{BUCKET_META_PREFIX}/{NAME}"));
assert!(before[&main].1 < 8192, "only a compact manifest belongs in the root");
assert!(before.keys().any(|key| key.contains(".pages/")), "large cache must be paged");
let mut restarted = DataUsageCache::default();
let revisions = restarted
.load_with_revisions(store.clone(), NAME)
.await
.expect("restart from durable pages");
let prior = restarted.checked_flatten("bucket").expect("all old entries");
restarted.replace(
"bucket/prefix-tail",
"bucket",
DataUsageEntry {
objects: 1,
versions: 1,
size: 4711,
..Default::default()
},
);
store.fail_puts_from.lock().await.insert(main.clone(), before[&main].0 + 1);
restarted
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect_err("commit interrupted after writing pages");
let interrupted = layout(&store).await;
let mut observer = DataUsageCache::default();
observer.load(store.clone(), NAME).await.expect("last root still readable");
assert_eq!(observer.checked_flatten("bucket").expect("previous coverage").size, prior.size);
store.fail_puts_from.lock().await.remove(&main);
restarted
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("retry interrupted commit");
observer.load(store.clone(), NAME).await.expect("load committed result");
let actual = observer.checked_flatten("bucket").expect("new root");
assert_eq!((actual.objects, actual.size), (4097, prior.size + 4711));
let after = layout(&store).await;
for (key, (writes, _)) in &interrupted {
if key.contains(".bin.pages/") {
assert_eq!(*writes, after[key].0, "retry restaged a previously successful immutable page");
}
}
let new_bytes: usize = after
.iter()
.filter(|(key, _)| !before.contains_key(*key))
.map(|(_, (_, size))| *size)
.sum();
assert!(
new_bytes < encoded / 3,
"one append staged {new_bytes} new bytes for a {encoded}-byte cache"
);
for (key, (writes, _)) in &before {
if key.contains(".pages/") {
assert_eq!(*writes, after[key].0, "a committed page was resubmitted");
}
}
restarted.info.next_cycle += 1;
let stale = restarted
.save_with_revisions_for_epoch(store.clone(), NAME, &first, 0, CancellationToken::new())
.await;
assert!(
matches!(stale, Err(EcstoreError::PreconditionFailed)),
"stale writer cannot replace the new root"
);
}
#[tokio::test]
async fn paged_checkpoint_cold_restore_spans_fixed_duration_and_repairs_corrupt_primary() {
let store = Arc::new(MemoryConfigStore::default());
let cache = seeded();
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("read revisions");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("write both copies");
store.checkpoint_page_delay_ms.store(16, Ordering::Relaxed);
let mut loaded = DataUsageCache::default();
let mut completed_at = None;
for round in 1..=128 {
if let Ok(result) = tokio::time::timeout(Duration::from_millis(26), loaded.load(store.clone(), NAME)).await {
result.expect("resume exact committed manifest");
completed_at = Some(round);
break;
}
}
assert!(
completed_at.is_some_and(|round| round > 1),
"cold recovery must advance across fixed deadlines"
);
store.checkpoint_page_delay_ms.store(0, Ordering::Relaxed);
let prior = loaded.checked_flatten("bucket").expect("cold cache totals");
assert_eq!((prior.objects, prior.size), (4096, 4096 * 4097 / 2));
{
let mut objects = store.objects.lock().await;
let (_, block) = objects
.iter_mut()
.find(|(key, block)| key.contains(".bin.pages/") && block.len() > 8192)
.expect("primary data page");
block[0] ^= 0xff;
}
let revisions = loaded
.load_with_revisions(store.clone(), NAME)
.await
.expect("read unaffected backup");
assert_eq!(
revisions,
DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("re-enter admission on same heads")
);
loaded
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("replace damaged primary generation");
store.objects.lock().await.retain(|key, _| !key.contains(".bkp"));
let mut primary = DataUsageCache::default();
primary.load(store, NAME).await.expect("repaired independent primary");
assert_eq!(primary.checked_flatten("bucket").expect("primary totals").size, prior.size);
}
#[tokio::test(start_paused = true)]
async fn paged_checkpoint_bucket_admission_uses_the_scan_budget_during_cold_load() {
let store = Arc::new(MemoryConfigStore::default());
let cache = seeded();
let revisions = DataUsageCache::read_revisions(store.clone(), NAME).await.unwrap();
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.unwrap();
store.checkpoint_page_delay_ms.store(16, Ordering::Relaxed);
let owner = CancellationToken::new();
let mut loaded = DataUsageCache::default();
for round in 0..128 {
let budget = ScannerCycleBudget::new_with_progress_tracking(
&owner,
ScannerCycleBudgetConfig {
max_duration: Some(Duration::from_millis(45)),
..Default::default()
},
);
// Exercise the same admission used by local and remote workers. The
// worker may drain after the deadline; only the scan token interrupts
// recovery here, as it does in the daemon.
let revisions = loaded
.load_for_scan(store.clone(), NAME, &budget.token(), &budget)
.await
.unwrap();
if revisions.is_some() {
assert!(round > 0, "the first slice cannot finish this physical restore");
assert!(!budget.token().is_cancelled(), "return work only to an active scan");
let totals = loaded.checked_flatten("bucket").expect("restored full bucket");
assert_eq!((totals.objects, totals.size), (4096, 4096 * 4097 / 2));
return;
}
}
panic!("bucket admission repeatedly consumed the entire budget restoring the same root");
}
#[tokio::test]
async fn paged_checkpoint_retirement_preserves_independent_backup_and_legacy_projection() {
let store = Arc::new(MemoryConfigStore::default());
let mut cache = seeded();
cache.info.snapshot_complete = true;
let first = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("initial revisions");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &first, 0, CancellationToken::new())
.await
.expect("persist first generation");
let original = layout(&store).await;
let main = memory_config_key(RUSTFS_META_BUCKET, &format!("{BUCKET_META_PREFIX}/{NAME}"));
let backup = format!("{main}.bkp");
let legacy =
DataUsageCache::unmarshal(&store.objects.lock().await[&main]).expect("old reader can read compact complete root");
let totals = legacy
.checked_flatten_complete_scope("bucket")
.expect("legacy compact totals");
assert_eq!((totals.objects, totals.size), (4096, 4096 * 4097 / 2));
let initial = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("first generation revisions");
cache.info.next_cycle += 1;
store
.fail_puts_from
.lock()
.await
.insert(backup.clone(), original[&backup].0 + 1);
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &initial, 0, CancellationToken::new())
.await
.expect("commit primary despite failed backup");
let updated = layout(&store).await;
for key in original.keys().filter(|key| key.contains(".pages/")) {
assert_eq!(
updated.contains_key(key),
key.contains(".bkp.pages/"),
"unexpected reclamation scope: {key}"
);
}
let mut latest = DataUsageCache::default();
latest.load(store.clone(), NAME).await.expect("new main remains readable");
assert_eq!(latest.info.next_cycle, cache.info.next_cycle);
store.objects.lock().await.remove(&main);
latest
.load(store, NAME)
.await
.expect("previous independent backup remains readable");
assert_eq!(latest.info.next_cycle + 1, cache.info.next_cycle);
}
#[tokio::test(start_paused = true)]
async fn paged_checkpoint_scan_handoff_checks_the_latest_root_before_using_its_totals() {
let store = Arc::new(MemoryConfigStore::default());
let mut cache = seeded();
cache.cache.clear();
let replace = |cache: &mut DataUsageCache, size| {
cache.replace(
"bucket",
"",
DataUsageEntry {
objects: 1,
size,
..Default::default()
},
);
};
replace(&mut cache, 17);
let revisions = DataUsageCache::read_revisions(store.clone(), NAME).await.unwrap();
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.unwrap();
let main = memory_config_key(RUSTFS_META_BUCKET, &format!("{BUCKET_META_PREFIX}/{NAME}"));
store.delayed_gets.lock().await.insert(main, Duration::from_secs(6));
let parent = CancellationToken::new();
let budget = || {
ScannerCycleBudget::new_with_progress_tracking(
&parent,
ScannerCycleBudgetConfig {
max_duration: Some(Duration::from_secs(10)),
..Default::default()
},
)
};
let first = budget();
let mut loaded = DataUsageCache::default();
assert!(
loaded
.load_for_scan(store.clone(), NAME, &first.token(), &first)
.await
.unwrap()
.is_none()
);
assert!(!first.token().is_cancelled(), "the slow load moved its result to the next admission");
let revisions = DataUsageCache::read_revisions(store.clone(), NAME).await.unwrap();
replace(&mut cache, 99);
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.unwrap();
let next = budget();
assert!(
loaded
.load_for_scan(store, NAME, &next.token(), &next)
.await
.unwrap()
.is_some()
);
assert_eq!(loaded.checked_flatten("bucket").expect("new root").size, 99);
}
@@ -1,276 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
#[tokio::test]
async fn indefinite_partial_checkpoints_keep_unreachable_bytes_bounded() {
let store = Arc::new(MemoryConfigStore::default());
let mut cache = seeded();
let mut initial_bytes = 0;
for round in 0..10 {
for (name, entry) in &mut cache.cache {
if name != "bucket" {
entry.size += 17;
}
}
// A single long-running cycle can checkpoint many times without changing cycle number.
assert!(!cache.info.snapshot_complete);
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("current heads");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("commit partial");
let current: usize = layout(&store)
.await
.iter()
.filter(|(path, _)| path.contains(".pages/"))
.map(|(_, (_, size))| size)
.sum();
if round == 0 {
initial_bytes = current;
assert!(initial_bytes > 100_000);
}
assert!(
current <= initial_bytes * 4,
"after {} partials, {current} page bytes for {initial_bytes} initially",
round + 1
);
}
let loaded = &mut DataUsageCache::default();
loaded.load(store, NAME).await.expect("restore bounded checkpoint");
assert_eq!(
loaded.checked_flatten("bucket").expect("valid restored tree").size,
cache.checked_flatten("bucket").expect("fixture tree").size
);
}
async fn reopen_checkpoint_store(store: &MemoryConfigStore) -> Arc<MemoryConfigStore> {
let reopened = Arc::new(MemoryConfigStore::default());
*reopened.objects.lock().await = store.objects.lock().await.clone();
*reopened.revisions.lock().await = store.revisions.lock().await.clone();
*reopened.put_counts.lock().await = store.put_counts.lock().await.clone();
reopened
}
#[tokio::test]
async fn abandoned_checkpoint_generation_is_reclaimed_after_an_inline_commit() {
let store = Arc::new(MemoryConfigStore::default());
let main = memory_config_key(RUSTFS_META_BUCKET, &format!("{BUCKET_META_PREFIX}/{NAME}"));
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("empty store");
let mut committed = empty_bucket_checkpoint();
committed
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("commit small checkpoint");
let before = layout(&store).await;
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("inline revision");
store.fail_puts_from.lock().await.insert(main.clone(), before[&main].0 + 1);
seeded()
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect_err("interrupt the root commit after staging the large checkpoint");
let staged: Vec<_> = layout(&store)
.await
.into_keys()
.filter(|path| path.contains(".bin.pages/") && !before.contains_key(path))
.collect();
assert!(staged.len() > 1, "the interrupted commit must have written pages");
assert_eq!(
DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("roots remain readable"),
revisions
);
// Preserve durable objects while dropping the interrupted writer's receipts.
let store = reopen_checkpoint_store(&store).await;
store.fail_prefix_deletes.store(true, Ordering::Relaxed);
committed.replace(
"bucket",
"",
DataUsageEntry {
objects: 1,
size: 17,
..Default::default()
},
);
committed
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("publish the different inline checkpoint despite interrupted cleanup");
let interrupted_cleanup = layout(&store).await;
assert!(staged.iter().all(|path| interrupted_cleanup.contains_key(path)));
// A second restart leaves only the new root's durable cleanup record.
let restarted = reopen_checkpoint_store(&store).await;
let mut restored = DataUsageCache::default();
let revisions = restored
.load_with_revisions(restarted.clone(), NAME)
.await
.expect("restore the committed inline checkpoint");
assert_eq!(restored.checked_flatten("bucket").expect("inline totals").size, 17);
restored
.save_with_revisions_for_epoch(restarted.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("reclaim the abandoned generation after restart");
let after = layout(&restarted).await;
assert!(staged.iter().all(|path| !after.contains_key(path)), "abandoned pages leaked");
restored.load(restarted, NAME).await.expect("load after reclaim");
assert_eq!(restored.checked_flatten("bucket").expect("retained inline totals").size, 17);
}
enum BackupDamage {
Missing,
Corrupt,
UnreadableMetadata,
}
async fn survives_lost_primary_after_backup_page_damage(damage: BackupDamage) {
let store = Arc::new(MemoryConfigStore::default());
let cache = seeded();
let first = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("empty heads");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &first, 0, CancellationToken::new())
.await
.expect("initial checkpoint");
let modify_tail = |cache: &mut DataUsageCache| {
cache.cache.get_mut("bucket/prefix-04095").expect("last leaf").size += 99;
};
let control = Arc::new(MemoryConfigStore::default());
let mut target = cache.clone();
modify_tail(&mut target);
let empty = DataUsageCache::read_revisions(control.clone(), NAME)
.await
.expect("empty control store");
target
.save_with_revisions_for_epoch(control.clone(), NAME, &empty, 0, CancellationToken::new())
.await
.expect("encode target in an independent fresh bundle");
{
let control_objects = control.objects.lock().await;
let mut objects = store.objects.lock().await;
let victim = objects
.iter()
.find_map(|(path, data)| {
// A fresh target bundle only contains currently reachable objects.
(path.contains(".bkp.pages/") && data.len() > 8192 && control_objects.get(path) == Some(data))
.then(|| path.clone())
})
.expect("a large unchanged leaf is reachable in both manifests");
match damage {
BackupDamage::Corrupt => objects.get_mut(&victim).expect("existing backup leaf")[0] ^= 1,
BackupDamage::Missing => {
objects.remove(&victim);
}
BackupDamage::UnreadableMetadata => {
drop(objects);
store.read_errors.lock().await.insert(victim, EcstoreError::FileCorrupt);
}
}
}
let mut from_main = DataUsageCache::default();
let revisions = from_main
.load_with_revisions(store.clone(), NAME)
.await
.expect("primary remains healthy");
modify_tail(&mut from_main);
from_main
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("incremental commit while primary is healthy");
let main = memory_config_key(RUSTFS_META_BUCKET, &format!("{BUCKET_META_PREFIX}/{NAME}"));
store.objects.lock().await.remove(&main);
let mut recovered = DataUsageCache::default();
recovered.load(store, NAME).await.expect("standalone cold backup recovery");
let actual = recovered
.checked_flatten("bucket")
.expect("a connected backup after losing its primary");
assert_eq!((actual.objects, actual.size), (4096, 4096 * 4097 / 2 + 99));
}
#[tokio::test]
async fn incremental_save_repairs_missing_backup_leaf() {
survives_lost_primary_after_backup_page_damage(BackupDamage::Missing).await;
}
#[tokio::test]
async fn incremental_save_repairs_corrupt_backup_leaf() {
survives_lost_primary_after_backup_page_damage(BackupDamage::Corrupt).await;
}
#[tokio::test]
async fn incremental_save_rebuilds_backup_with_unreadable_page_metadata() {
survives_lost_primary_after_backup_page_damage(BackupDamage::UnreadableMetadata).await;
}
#[tokio::test]
async fn unreclaimed_partial_generation_bounds_staging_and_can_retry() {
let store = Arc::new(MemoryConfigStore::default());
let mut cache = seeded();
cache.info.snapshot_complete = true;
let empty = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("empty store");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &empty, 0, CancellationToken::new())
.await
.expect("committed predecessor");
store.fail_prefix_deletes.store(true, Ordering::Relaxed);
cache.info.snapshot_complete = false;
cache.info.next_cycle += 1;
for _ in 0..8 {
for (name, entry) in &mut cache.cache {
if name != "bucket" {
entry.size += 17;
}
}
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("current heads");
let before = layout(&store).await;
if let Err(error) = cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
{
assert!(error.to_string().contains("reclaim"), "unexpected save failure: {error}");
assert_eq!(before, layout(&store).await, "a blocked retirement must not stage further objects");
assert!(
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.is_err()
);
assert_eq!(
before,
layout(&store).await,
"retry while cleanup is unavailable must leave both generations readable"
);
let mut previous = DataUsageCache::default();
previous.load(store.clone(), NAME).await.expect("last committed checkpoint");
assert!(previous.checked_flatten("bucket").is_some());
store.fail_prefix_deletes.store(false, Ordering::Relaxed);
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("save after previous retirement is reclaimed");
previous.load(store.clone(), NAME).await.expect("read latest checkpoint");
assert_eq!(
cache.checked_flatten("bucket").expect("fixture").size,
previous.checked_flatten("bucket").expect("recovered root").size
);
return;
}
}
panic!("persistent retirement failure allowed unbounded staging");
}
@@ -160,7 +160,6 @@ async fn issue_8297_contended_follower_clears_only_transient_cycle_recovery() {
ScannerMaintenanceFeatures::default(),
None,
runtime.startup_token(),
&mut None,
),
)
.await
@@ -1,275 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
use crate::data_usage_define::{DATA_USAGE_SCAN_CHECKPOINT_VERSION, DataUsageCacheRevisions, DataUsageScanIdentity};
use tokio::sync::{Notify, OwnedSemaphorePermit, Semaphore};
const NAME: &str = "bucket/.usage-cache.bin";
const COUNT: usize = 1536;
struct ReadWindow {
pages: usize,
device: Arc<Semaphore>,
completed: std::sync::Mutex<Vec<String>>,
deadline: Notify,
}
tokio::task_local! {
static READ_WINDOW: Arc<ReadWindow>;
}
// Model a serial device with one page of I/O time per admission. Completing
// a second read would exceed the deadline, so the caller drops that waiter.
pub(super) async fn admit_page(object: &str) -> Option<OwnedSemaphorePermit> {
let window = READ_WINDOW.try_with(Arc::clone).ok()?;
let permit = window.device.clone().acquire_owned().await.expect("device stays open");
{
let mut completed = window.completed.lock().expect("device history");
if completed.len() < window.pages {
completed.push(object.into());
return Some(permit);
}
}
drop(permit);
window.deadline.notify_one();
std::future::pending().await
}
async fn window(store: &Arc<MemoryConfigStore>, loaded: &mut DataUsageCache) -> (Option<DataUsageCacheRevisions>, Vec<String>) {
let window = Arc::new(ReadWindow {
pages: 1,
device: Arc::new(Semaphore::new(1)),
completed: Default::default(),
deadline: Notify::new(),
});
let result = READ_WINDOW
.scope(window.clone(), async {
tokio::select! {
biased;
value = loaded.load_with_revisions(store.clone(), NAME) => Some(value.expect("checkpoint load")),
() = window.deadline.notified() => None,
}
})
.await;
let pages = std::mem::take(&mut *window.completed.lock().expect("device history"));
(result, pages)
}
async fn fixture() -> (Arc<MemoryConfigStore>, DataUsageCache) {
let store = Arc::new(MemoryConfigStore::default());
let mut cache = DataUsageCache::default();
cache.info.name = "bucket".into();
cache.info.source = Some(DataUsageCacheSource::new(0, 0));
cache.info.scan_identity = Some(DataUsageScanIdentity {
version: DATA_USAGE_SCAN_CHECKPOINT_VERSION,
bucket_incarnation: uuid::Uuid::from_u128(9),
set_layout: DataUsageScanPlanDigest([7; 32]),
publication_epoch: 0,
tier_registry_generation: 1,
scan_mode: HealScanMode::Normal,
});
cache.replace("bucket", "", DataUsageEntry::default());
for key in 0..COUNT {
cache.replace(
&format!("bucket/key-{key:08}"),
"bucket",
DataUsageEntry {
objects: 1,
size: key + 1,
..Default::default()
},
);
}
let revisions = DataUsageCache::read_revisions(store.clone(), NAME)
.await
.expect("initial revisions");
cache
.save_with_revisions_for_epoch(store.clone(), NAME, &revisions, 0, CancellationToken::new())
.await
.expect("seed both copies");
(store, cache)
}
async fn corrupt_primary(store: &MemoryConfigStore) {
let mut objects = store.objects.lock().await;
let mut pages = 0;
for (_, data) in objects.iter_mut().filter(|(path, _)| path.contains(".bin.pages/")) {
data[0] ^= 1;
pages += 1;
}
assert!(pages > 4, "fixture must span more than one physical read batch");
}
async fn finish(store: &Arc<MemoryConfigStore>, backup: bool) {
finish_across_windows(store, backup, None).await;
}
async fn finish_across_windows(store: &Arc<MemoryConfigStore>, backup: bool, competing: Option<&Arc<MemoryConfigStore>>) {
let mut loaded = DataUsageCache::default();
let mut main_reads = 0;
let mut backup_reads = 0;
for _ in 0..128 {
let (result, pages) = window(store, &mut loaded).await;
for page in pages {
if page.contains(".bkp.pages/") {
backup_reads += 1;
} else {
main_reads += 1;
}
}
if result.is_some() {
let total = loaded.checked_flatten("bucket").expect("restored bucket");
assert_eq!(total.objects, COUNT);
assert_eq!(total.size, COUNT * (COUNT + 1) / 2);
if backup {
assert_eq!(main_reads, 1, "read the corrupt primary once for this revision");
assert!(backup_reads > 4, "the independent backup must be restored across admissions");
} else {
assert!(main_reads > 4);
assert_eq!(backup_reads, 0);
}
return;
}
if let Some(other) = competing {
tokio::time::advance(Duration::from_secs(2 * 60 * 60)).await;
let _ = window(other, &mut DataUsageCache::default()).await;
}
}
panic!("checkpoint did not converge: {main_reads} primary and {backup_reads} backup page reads");
}
#[tokio::test]
async fn serial_backend_restores_one_verified_page_per_deadline() {
let (store, _) = fixture().await;
finish(&store, false).await;
}
#[tokio::test]
async fn concurrent_cancellations_keep_the_longer_verified_prefix() {
let (store, _) = fixture().await;
let longer = Arc::new(ReadWindow {
pages: 3,
device: Arc::new(Semaphore::new(1)),
completed: Default::default(),
deadline: Notify::new(),
});
let mut first = DataUsageCache::default();
let mut read = Box::pin(READ_WINDOW.scope(longer.clone(), first.load(store.clone(), NAME)));
tokio::select! {
result = &mut read => panic!("checkpoint unexpectedly finished within three reads: {result:?}"),
() = longer.deadline.notified() => {}
}
let mut concurrent = DataUsageCache::default();
assert!(window(&store, &mut concurrent).await.0.is_none());
drop(read);
let (_, next) = window(&store, &mut concurrent).await;
let previous = longer.completed.lock().expect("first reader history");
assert_eq!(previous.len(), 3);
assert!(
!previous.contains(&next[0]),
"a shorter concurrent cancellation displaced a verified prefix"
);
}
#[tokio::test]
async fn corrupt_primary_yields_future_admissions_to_the_healthy_backup() {
let (store, _) = fixture().await;
corrupt_primary(&store).await;
finish(&store, true).await;
}
#[tokio::test]
async fn new_primary_revision_supersedes_an_incomplete_backup_restore() {
let (store, _) = fixture().await;
corrupt_primary(&store).await;
let mut loaded = DataUsageCache::default();
assert!(window(&store, &mut loaded).await.0.is_none());
let (result, pages) = window(&store, &mut loaded).await;
assert!(result.is_none());
assert!(pages[0].contains(".bkp.pages/"), "second admission should advance backup");
let mut new_primary = DataUsageCache::default();
new_primary.info.name = "bucket".into();
new_primary.replace(
"bucket",
"",
DataUsageEntry {
objects: 1,
size: 19,
..Default::default()
},
);
let root = memory_config_key(RUSTFS_META_BUCKET, &format!("{}/{NAME}", crate::BUCKET_META_PREFIX));
let bytes = rmp_serde::to_vec_named(&new_primary).expect("replacement main root");
store.objects.lock().await.insert(root.clone(), bytes);
*store.revisions.lock().await.get_mut(&root).expect("primary revision") += 1;
let (result, pages) = window(&store, &mut loaded).await;
assert!(result.is_some(), "must prefer the replacement main head immediately");
assert!(pages.is_empty(), "must discard work on the older backup");
let total = loaded.checked_flatten("bucket").expect("new primary root");
assert_eq!((total.objects, total.size), (1, 19));
}
async fn inject_primary_page_error(store: &MemoryConfigStore, error: EcstoreError) {
let errors = store
.objects
.lock()
.await
.keys()
.filter(|key| key.contains(".bin.pages/"))
.map(|key| (key.clone(), error.clone()))
.collect();
*store.read_errors.lock().await = errors;
}
#[tokio::test(start_paused = true)]
async fn a_transient_primary_page_error_does_not_schedule_the_backup() {
let (store, _) = fixture().await;
inject_primary_page_error(&store, EcstoreError::SlowDown).await;
let mut loaded = DataUsageCache::default();
assert!(window(&store, &mut loaded).await.0.is_none());
store.read_errors.lock().await.clear();
finish(&store, false).await;
}
#[tokio::test]
async fn backup_phase_is_bound_to_its_storage_instance() {
let (damaged, _) = fixture().await;
corrupt_primary(&damaged).await;
assert!(window(&damaged, &mut DataUsageCache::default()).await.0.is_none());
let (healthy, _) = fixture().await;
let first = DataUsageCache::read_revisions(damaged.clone(), NAME)
.await
.expect("failed primary revision");
let second = DataUsageCache::read_revisions(healthy.clone(), NAME)
.await
.expect("other storage revision");
assert_eq!(first, second, "both stores must expose the same ETags");
finish(&healthy, false).await;
}
#[tokio::test(start_paused = true)]
async fn idle_restore_keeps_verified_pages_until_another_bucket_needs_its_slot() {
let (primary, _) = fixture().await;
let (other, _) = fixture().await;
finish_across_windows(&primary, false, Some(&other)).await;
}
#[tokio::test(start_paused = true)]
async fn idle_restore_keeps_the_failed_primary_revision_across_scheduled_rounds() {
let (primary, _) = fixture().await;
let (other, _) = fixture().await;
corrupt_primary(&primary).await;
corrupt_primary(&other).await;
finish_across_windows(&primary, true, Some(&other)).await;
}
#[tokio::test(start_paused = true)]
async fn physical_primary_page_corruption_falls_back_to_the_healthy_copy() {
let (store, _) = fixture().await;
inject_primary_page_error(&store, EcstoreError::FileCorrupt).await;
finish(&store, true).await;
}
+61 -445
View File
@@ -526,19 +526,6 @@ fn data_usage_entry_has_progress(entry: &DataUsageEntry) -> bool {
data_usage_root_has_progress(entry)
}
#[cfg(test)]
tokio::task_local! {
static TEST_FORCE_COMPACTION_WIDTH: usize;
}
fn force_compaction_width() -> usize {
#[cfg(test)]
if let Ok(width) = TEST_FORCE_COMPACTION_WIDTH.try_with(|width| *width) {
return width;
}
DATA_SCANNER_FORCE_COMPACT_AT_FOLDERS
}
/// Root-fanout limit for `DataUsageCache::force_compact` at the end of a sweep.
///
/// An interrupted sweep still has to seal its resume frontier, so it keeps the
@@ -860,7 +847,6 @@ pub struct FolderScanner {
resume_failed_paths: Vec<String>,
coverage_gap: bool,
raw_enumeration_progress: Vec<RawEnumerationProgress>,
directory_checkpoints: HashMap<String, HashMap<String, directory_cursor::Saved>>,
pending_size_reconciliation_keys: HashSet<String>,
pending_size_reconciliation_scopes: HashSet<String>,
pending_size_reconciliation_truncated: bool,
@@ -880,7 +866,6 @@ struct RawEnumerationProgress {
entries_seen: u64,
digest: Sha256,
page_index: Option<RawEnumerationPageWriter>,
sealed_pages: Option<(RawEnumerationPageIndex, usize)>,
}
impl RawEnumerationProgress {
@@ -896,34 +881,10 @@ impl RawEnumerationProgress {
entries_seen: 0,
digest,
page_index,
sealed_pages: None,
}
}
fn from_sealed(parent: &str, index: &RawEnumerationPageIndex) -> Option<Self> {
use crate::raw_page_index::RawEnumerationPageOwnerStatus;
let count = match index.status() {
RawEnumerationPageOwnerStatus::Building { indexed_entries, .. }
| RawEnumerationPageOwnerStatus::Ready { indexed_entries, .. } => usize::try_from(indexed_entries).ok()?,
RawEnumerationPageOwnerStatus::Unsupported => return None,
};
if count == 0 {
return None;
}
Some(Self {
parent: parent.to_owned(),
last_entry: None,
entries_seen: 0,
digest: Sha256::new(),
page_index: None,
sealed_pages: Some((index.clone(), count)),
})
}
fn record_entry(&mut self, entry: &str) {
if let Some((index, _)) = self.sealed_pages.take() {
*self = Self::new(&self.parent, Some(index));
}
update_raw_enumeration_digest(&mut self.digest, b"entry", entry.as_bytes());
self.last_entry = Some(entry.to_string());
self.entries_seen = self.entries_seen.saturating_add(1);
@@ -947,9 +908,6 @@ impl RawEnumerationProgress {
}
fn page_index(&self) -> Option<RawEnumerationPageIndex> {
if let Some((index, _)) = &self.sealed_pages {
return Some(index.clone());
}
self.page_index
.as_ref()
.filter(|index| index.indexed_entry_count() > 0)
@@ -961,9 +919,6 @@ impl RawEnumerationProgress {
}
fn checkpointable_entry_count(&self) -> usize {
if let Some((_, count)) = &self.sealed_pages {
return *count;
}
self.page_index
.as_ref()
.map_or(0, RawEnumerationPageWriter::indexed_entry_count)
@@ -1036,26 +991,16 @@ async fn wait_for_scanner_io<T>(ctx: &CancellationToken, wait: impl std::future:
}
}
pub(crate) use directory_cursor::parked_bucket_disks;
use directory_cursor::{DirectoryScope, ScannerDirectory};
struct DirectoryStream {
struct ScannerDirectory {
reader: native_io::ReadDir,
batch_entries: usize,
#[cfg(test)]
ordered: Option<tests::erasure_probe::OrderedEntries>,
}
impl DirectoryStream {
async fn open_at(path: &str, anchor: &native_io::DirectoryAnchor) -> std::io::Result<Self> {
Ok(Self {
reader: native_io::ReadDir::open_at(path, anchor).await?,
#[cfg(test)]
ordered: None,
})
}
async fn open(path: &str, indexed: bool) -> std::io::Result<Self> {
let reader = native_io::ReadDir::open(path, indexed).await?;
impl ScannerDirectory {
async fn open(path: &str) -> std::io::Result<Self> {
let reader = native_io::ReadDir::open(path).await?;
#[cfg(test)]
let (reader, ordered) = {
let mut reader = reader;
@@ -1064,6 +1009,7 @@ impl DirectoryStream {
};
Ok(Self {
reader,
batch_entries: 0,
#[cfg(test)]
ordered,
})
@@ -1088,14 +1034,11 @@ async fn next_scanner_dir_entry(
wait_for_scanner_io(ctx, tokio::task::yield_now()).await?;
entries.batch_entries = 0;
}
let entry = wait_for_scanner_io(ctx, run_scanner_node_operation(admission, ctx, entries.peek_entry())).await???;
if entry.as_ref().is_some_and(|item| !item.is_recorded()) {
let entry = wait_for_scanner_io(ctx, run_scanner_node_operation(admission, ctx, entries.next_entry())).await???;
if entry.is_some() {
// Tokio prefetches bounded chunks. Pacing consumption also paces the
// next refill, without charging an extra entry for EOF.
wait_for_scanner_io(ctx, sleeper.admit_disk_io(1, 0)).await?;
}
if entry.is_some() {
entries.accept_entry();
entries.batch_entries += 1;
}
Ok(entry)
@@ -1113,7 +1056,7 @@ impl FolderScanner {
&self,
folder: &CachedFolder,
into: &DataUsageEntry,
child_name: &str,
child: &CachedFolder,
child_hash: &DataUsageHash,
abandoned_children: &DataUsageHashMap,
) -> bool {
@@ -1133,7 +1076,8 @@ impl FolderScanner {
return false;
}
let Some(entry) = child_name
let Some(entry) = child
.name
.strip_prefix(folder.name.as_str())
.and_then(|entry| entry.strip_prefix('/'))
else {
@@ -1142,21 +1086,6 @@ impl FolderScanner {
!entry.is_empty() && !entry.contains('/') && !prefix_scan_scope.contains(entry)
}
fn can_reuse_scoped_child(&self, folder: &CachedFolder, into: &DataUsageEntry, name: &str, hash: &DataUsageHash) -> bool {
self.prefix_scan_scope.is_some()
&& self
.old_cache
.find(&folder.name)
.is_some_and(|parent| self.should_reuse_clean_root_child(folder, into, name, hash, &parent.children))
}
fn can_restore_linked_child(&self, folder: &CachedFolder, into: &DataUsageEntry, name: &str) -> bool {
self.can_reuse_covered_namespace(name, false)
|| (self.prefix_scan_scope.is_some()
&& self.old_cache.find(name).is_some()
&& self.can_reuse_scoped_child(folder, into, name, &hash_path(name)))
}
fn reuse_clean_root_child(&mut self, child: &CachedFolder, child_hash: &DataUsageHash, into: &mut DataUsageEntry) {
self.new_cache.copy_with_children(&self.old_cache, child_hash, &child.parent);
if let Some(updates) = &mut self.usage_updates {
@@ -1393,12 +1322,7 @@ impl FolderScanner {
/// Records one raw entry. Returns whether a durable index holds it, which
/// is what makes stopping at this entry recoverable.
#[cfg(test)]
fn record_raw_enumeration_entry(&mut self, parent: &str, entry: &str) -> bool {
self.record_raw_enumeration_entry_with_stream(parent, entry, false)
}
fn record_raw_enumeration_entry_with_stream(&mut self, parent: &str, entry: &str, continues_stream: bool) -> bool {
if self.old_cache.info.scan_progress.is_none() {
return false;
}
@@ -1410,11 +1334,8 @@ impl FolderScanner {
self.raw_enumeration_progress.truncate(position + 1);
} else {
let page_index = self.raw_enumeration_page_index_for_parent(parent).map(clone_cache_value);
let mut progress = RawEnumerationProgress::new(parent, page_index);
if continues_stream && let Some(writer) = &mut progress.page_index {
writer.continue_native_stream();
}
self.raw_enumeration_progress.push(progress);
self.raw_enumeration_progress
.push(RawEnumerationProgress::new(parent, page_index));
}
self.raw_enumeration_progress.last_mut().is_some_and(|progress| {
progress.record_entry(entry);
@@ -1481,17 +1402,6 @@ impl FolderScanner {
.map(|(index, _)| index)
}
fn saved_directories(&self) -> Vec<DirectoryCheckpoint> {
let mut snapshots: Vec<_> = self
.directory_checkpoints
.values()
.flat_map(HashMap::values)
.filter_map(|slot| slot.lock().unwrap_or_else(|p| p.into_inner()).clone())
.collect();
snapshots.sort_by(|left, right| (left.parent(), left.endpoint()).cmp(&(right.parent(), right.endpoint())));
snapshots
}
/// The walk path except the directory the resume state selects.
fn raw_enumeration_path_page_indexes(&self) -> Vec<RawEnumerationPageIndex> {
let selected = self.selected_raw_enumeration_progress();
@@ -1543,22 +1453,9 @@ impl FolderScanner {
}
fn maybe_send_checkpoint(&mut self, folder: &CachedFolder, hash: &DataUsageHash, into: &DataUsageEntry) {
self.maybe_send_owned_checkpoint(folder, hash, into, None);
}
// A compact accumulator is checkpointable only at the boundary where
// its owning frame has accepted a complete child. Descendant frames may
// temporarily share the same accumulator and cannot seal it themselves.
fn maybe_send_owned_checkpoint(
&mut self,
folder: &CachedFolder,
hash: &DataUsageHash,
into: &DataUsageEntry,
work: Option<&directory_cursor::DirectoryWork>,
) {
let Some(checkpoint_tx) = self.checkpoint_tx.clone() else { return };
let elapsed = self.last_checkpoint_at.elapsed();
if (into.compacted && work.is_none())
if into.compacted
|| self.new_cache.info.scan_progress.is_none()
|| elapsed < checkpoint_interval_for_build_time(self.last_checkpoint_build_time)
|| (self.checkpoint_objects.saturating_sub(self.last_checkpoint_objects) < SCANNER_CHECKPOINT_OBJECT_INTERVAL
@@ -1566,7 +1463,7 @@ impl FolderScanner {
{
return;
}
if self.new_cache.root().is_none() && self.raw_enumeration_progress.is_empty() && work.is_none() {
if self.new_cache.root().is_none() && self.raw_enumeration_progress.is_empty() {
return;
}
@@ -1582,9 +1479,6 @@ impl FolderScanner {
// Invalid partial graphs must not trigger a fresh O(N) clone on every object.
self.last_checkpoint_objects = self.checkpoint_objects;
self.last_checkpoint_at = Instant::now();
if let Some(work) = work {
work.checkpoint();
}
let snapshot = self.checkpoint_snapshot(folder, hash, into);
self.last_checkpoint_build_time = self.last_checkpoint_at.elapsed();
if let Some(snapshot) = snapshot {
@@ -1614,7 +1508,6 @@ impl FolderScanner {
snapshot.checked_flatten_complete_scope(&snapshot.info.name)?;
snapshot.info.last_update = Some(SystemTime::now());
snapshot.info.snapshot_complete = false;
snapshot.info.scan_directory_work = self.saved_directories();
let (cursor, page_index) = self.peek_raw_enumeration_resume_state();
snapshot.info.scan_raw_enumeration_path_page_indexes = self.raw_enumeration_path_page_indexes();
snapshot.info.scan_raw_enumeration_cursor = cursor;
@@ -1622,24 +1515,13 @@ impl FolderScanner {
snapshot.seal_scan_frontier(self.coverage_frontier.as_deref()).ok()?;
// A resumed readdir can run before covered subtrees are copied. Keep
// its durable receipt until this snapshot can represent that coverage.
let compacted_work = snapshot
.info
.scan_directory_work
.iter()
.filter_map(|directory| directory.progress(&snapshot.info));
if self
.coverage_frontier
.as_deref()
.is_some_and(|frontier| !compacted_work.clone().any(|proof| proof.covers(frontier)))
&& snapshot.info.scan_coverage_receipt.is_none()
{
if self.coverage_frontier.is_some() && snapshot.info.scan_coverage_receipt.is_none() {
return None;
}
// The receipt was just sealed from this snapshot; do not hash it twice.
if snapshot.info.scan_raw_enumeration_cursor.is_none()
&& snapshot.info.scan_raw_enumeration_page_index.is_none()
&& snapshot.info.scan_coverage_receipt.is_none()
&& snapshot.info.scan_directory_work.is_empty()
{
return None;
}
@@ -1983,15 +1865,7 @@ impl FolderScanner {
folder: CachedFolder,
into: &mut DataUsageEntry,
) -> Result<(), ScannerError> {
if self.old_cache.info.scan_directory_source.is_none()
&& self.old_cache.info.scan_identity.is_some()
&& self.old_cache.info.scan_progress.is_some()
{
let source = wait_for_scanner_io(&ctx, directory_cursor::physical_source(&self.local_disk)).await??;
self.old_cache.info.scan_directory_source = Some(source.clone());
self.new_cache.info.scan_directory_source = Some(source);
}
Box::pin(self.scan_folder_inner(ctx, folder, into, FolderScanMode::Namespace, false))
self.scan_folder_inner(ctx, folder, into, FolderScanMode::Namespace, false)
.await
.map(|_| ())
}
@@ -2098,43 +1972,9 @@ impl FolderScanner {
// directory that vanished during iteration instead of failing the
// whole parent subtree. The bucket root (no parent) still propagates
// NotFound so namespace removal is detected by the caller.
// A small object directory normally finishes in one call. Allocate
// listing state at the bucket root or after an interruption has
// actually left this directory on the saved traversal path.
let info = &self.old_cache.info;
let previously_interrupted = info
.scan_raw_enumeration_cursor
.as_ref()
.is_some_and(|cursor| cursor.parent == folder.name)
|| info
.scan_raw_enumeration_page_index
.iter()
.chain(&info.scan_raw_enumeration_path_page_indexes)
.any(|index| index.parent() == Some(folder.name.as_str()));
let mut directory_scope = (folder.parent.is_none()
|| previously_interrupted
|| self.directory_checkpoints.contains_key(&folder.name)
|| directory_cursor::is_parked(&dir_path))
.then(|| DirectoryScope::new(&self.local_disk, &self.old_cache, mode, self.prefix_scan_scope.clone()))
.flatten();
if let Some(scope) = &mut directory_scope {
scope.bind_source(self.old_cache.info.scan_directory_source.as_deref());
}
let saved = directory_scope.as_ref().map(|owner| {
self.directory_checkpoints
.entry(folder.name.clone())
.or_default()
.entry(owner.endpoint().to_owned())
.or_default()
.clone()
});
let mut dir_reader = match wait_for_scanner_io(
&ctx,
run_scanner_node_operation(
self.node_admission.as_ref(),
&ctx,
ScannerDirectory::open(&dir_path, &folder.name, directory_scope, self.budget.clone(), saved),
),
run_scanner_node_operation(self.node_admission.as_ref(), &ctx, ScannerDirectory::open(&dir_path)),
)
.await??
{
@@ -2157,48 +1997,16 @@ impl FolderScanner {
if mode != FolderScanMode::Namespace {
self.coverage_gap |= e.kind() == ErrorKind::NotADirectory && self.old_cache.info.scan_progress.is_some();
done_folder();
self.directory_checkpoints.remove(&folder.name);
return Ok(FolderScanOutcome::Vanished);
}
None
}
Err(e) => return Err(ScannerError::Io(e)),
};
if dir_reader.as_ref().is_some_and(|reader| reader.directory_replaced) && self.resume_frontier.is_some() {
// Names from a replaced directory cannot validate the saved
// child prefix. Finish this walk only as an observation.
self.coverage_gap = true;
self.resume_frontier = None;
}
let mut pending_entry_progress = 0_u64;
let mut last_entry_progress = Instant::now();
if let Some(reader) = &mut dir_reader {
reader.hold_abandoned(&mut abandoned_children);
}
let indexed = dir_reader.as_ref().is_some_and(ScannerDirectory::indexed);
let mut raw_enumeration_complete = false;
let continues_stream = dir_reader.as_ref().is_some_and(ScannerDirectory::continues_stream);
// A sealed work queue only emits the two classification markers;
// it never needs the raw-name membership table again.
let raw_enumeration_committed_entries = if dir_reader.as_ref().is_some_and(ScannerDirectory::finished_listing) {
// A later quantum can stop in a child. Its durable proof
// still needs every ancestor's prior immutable pages, even
// though this cursor need not enumerate those names again.
if let Some(progress) = self
.old_cache
.info
.scan_raw_enumeration_page_index
.iter()
.chain(&self.old_cache.info.scan_raw_enumeration_path_page_indexes)
.find(|index| index.parent() == Some(folder.name.as_str()))
.and_then(|index| RawEnumerationProgress::from_sealed(&folder.name, index))
{
self.raw_enumeration_progress.push(progress);
}
HashSet::new()
} else {
self.raw_enumeration_committed_entry_oracle(&folder.name)
};
let raw_enumeration_committed_entries = self.raw_enumeration_committed_entry_oracle(&folder.name);
let raw_replay_floor = u64::try_from(raw_enumeration_committed_entries.len()).unwrap_or(u64::MAX);
let mut raw_entries_observed = 0_u64;
let mut raw_entries_charged = 0_u64;
@@ -2209,11 +2017,12 @@ impl FolderScanner {
loop {
// Hold at most one metadata entry until a candidate reaches
// EOF: a later part must not leave object accounting or ILM work.
let (entry, replayed_metadata) = if let Some(reader) = dir_reader.as_mut().filter(|_| !raw_enumeration_complete) {
let (entry, replayed_metadata) = if let Some(reader) = dir_reader.as_mut() {
let entry = match next_scanner_dir_entry(&ctx, &self.sleeper, reader, self.node_admission.as_ref()).await {
Ok(Some(entry)) => entry,
Ok(None) => {
raw_enumeration_complete = true;
dir_reader = None;
continue;
}
Err(ScannerError::Io(e))
@@ -2233,6 +2042,7 @@ impl FolderScanner {
"Scanner folder state updated"
);
raw_enumeration_complete = true;
dir_reader = None;
continue;
}
Err(ScannerError::Io(e)) if e.kind() == ErrorKind::NotADirectory => {
@@ -2247,12 +2057,12 @@ impl FolderScanner {
"Scanner folder state updated"
);
raw_enumeration_complete = true;
dir_reader = None;
continue;
}
Err(e) => return Err(e),
};
let marker = entry.is_recorded();
(entry, marker)
(entry, false)
} else {
raw_enumeration_complete = true;
if candidate_unclassified {
@@ -2271,7 +2081,6 @@ impl FolderScanner {
self.budget.record_entries_visited(pending_entry_progress);
self.finish_raw_enumeration_parent(&folder.name);
done_folder();
self.directory_checkpoints.remove(&folder.name);
return Ok(FolderScanOutcome::Namespace);
}
candidate_unclassified = false;
@@ -2285,11 +2094,7 @@ impl FolderScanner {
..
}
) && deferred_metadata.is_none()
&& dir_reader
.as_ref()
.and_then(ScannerDirectory::folder_count)
.unwrap_or(queued_folders.len())
== 0;
&& queued_folders.is_empty();
if !empty_object_child {
if !self.budget.try_start_directory() {
return Err(ScannerError::Other("Operation cancelled".to_string()));
@@ -2309,25 +2114,21 @@ impl FolderScanner {
// its old size, so charging only that tail keeps each
// budget unit durable even if the listing order changed.
raw_entries_observed = raw_entries_observed.saturating_add(1);
let raw_entry_is_new = (continues_stream || raw_entries_observed > raw_replay_floor)
&& !raw_enumeration_committed_entries.contains(&file_name);
#[cfg(test)]
let raw_entry_is_new =
raw_entries_observed > raw_replay_floor && !raw_enumeration_committed_entries.contains(&file_name);
if raw_entry_is_new {
#[cfg(test)]
tests::enumeration_restart::observe_raw_entry(&dir_path, &entry.file_name(), &self.budget);
pending_entry_progress = pending_entry_progress.saturating_add(1);
if pending_entry_progress >= SCANNER_ENTRY_PROGRESS_BATCH
|| last_entry_progress.elapsed() >= SCANNER_ENTRY_PROGRESS_INTERVAL
{
self.budget.record_entries_visited(pending_entry_progress);
pending_entry_progress = 0;
last_entry_progress = Instant::now();
}
}
// Physical discovery is progress even when a changed directory
// must replay names retained by its logical page index. Budget
// admission below still charges only newly durable entries.
pending_entry_progress = pending_entry_progress.saturating_add(1);
if pending_entry_progress >= SCANNER_ENTRY_PROGRESS_BATCH
|| last_entry_progress.elapsed() >= SCANNER_ENTRY_PROGRESS_INTERVAL
{
self.budget.record_entries_visited(pending_entry_progress);
pending_entry_progress = 0;
last_entry_progress = Instant::now();
}
let raw_entry_is_durable =
self.record_raw_enumeration_entry_with_stream(&folder.name, &file_name, continues_stream);
let raw_entry_is_durable = self.record_raw_enumeration_entry(&folder.name, &file_name);
// Object metadata and the entries behind it are charged to
// the object budget; this one covers listing work.
let object_entry = file_name == STORAGE_FORMAT_FILE || deferred_metadata.is_some();
@@ -2341,9 +2142,6 @@ impl FolderScanner {
}
self.maybe_send_checkpoint(&folder, &this_hash, into);
}
if !replayed_metadata && dir_reader.as_ref().is_some_and(|reader| reader.enumeration_only) {
continue;
}
let is_storage_format_entry = file_name == STORAGE_FORMAT_FILE;
if candidate_unclassified && is_storage_format_entry {
deferred_metadata = Some(entry);
@@ -2362,15 +2160,12 @@ impl FolderScanner {
// Ignore entries that disappeared during traversal or hit symlink
// loops, but propagate other walk errors.
let file_type = if entry.is_recorded()
&& let Some(kind) = entry.cached_type()
let mut entry_type = match wait_for_scanner_io(
&ctx,
run_scanner_node_operation(self.node_admission.as_ref(), &ctx, entry.file_type()),
)
.await??
{
Ok(kind)
} else {
wait_for_scanner_io(&ctx, run_scanner_node_operation(self.node_admission.as_ref(), &ctx, entry.file_type()))
.await??
};
let mut entry_type = match file_type {
Ok(entry_type) => entry_type,
Err(e) if e.kind() == ErrorKind::NotFound => {
debug!(
@@ -2407,7 +2202,6 @@ impl FolderScanner {
// namespace coverage. Discard its provisional resume owner.
self.finish_raw_enumeration_parent(&folder.name);
done_folder();
self.directory_checkpoints.remove(&folder.name);
return Ok(FolderScanOutcome::ErasureData);
}
@@ -2508,7 +2302,7 @@ impl FolderScanner {
object_heal_prob_div: folder.object_heal_prob_div,
};
if exists && self.should_reuse_clean_root_child(&folder, into, &this.name, &h, &abandoned_children) {
if exists && self.should_reuse_clean_root_child(&folder, into, &this, &h, &abandoned_children) {
abandoned_children.remove(&clone_cache_value(&h.0));
self.reuse_clean_root_child(&this, &h, into);
} else if exists {
@@ -2734,11 +2528,7 @@ impl FolderScanner {
item.transform_meta_dir();
let resolved = path_join_buf(&[&item.bucket, &item.object_path()]);
abandoned_children.remove(&resolved);
if let Some(reader) = &mut dir_reader {
reader.resolve_abandoned(&resolved);
}
abandoned_children.remove(&path_join_buf(&[&item.bucket, &item.object_path()]));
apply_scanner_size_summary(into, &sz);
if !sz.size_reconciliation.is_empty() {
@@ -2772,19 +2562,7 @@ impl FolderScanner {
self.budget.record_entries_visited(pending_entry_progress);
// A directory with queued children keeps its index until they end:
// a restart replays this listing to reach the unfinished child.
if indexed && dir_reader.as_ref().is_some_and(|reader| !reader.finished_listing()) {
return Err(ScannerError::Io(std::io::Error::new(
ErrorKind::Interrupted,
"scanner directory changed before listing completed",
)));
}
if raw_enumeration_complete
&& dir_reader
.as_ref()
.and_then(ScannerDirectory::folder_count)
.unwrap_or(queued_folders.len())
== 0
{
if raw_enumeration_complete && queued_folders.is_empty() {
self.finish_raw_enumeration_parent(&folder.name);
}
@@ -2798,18 +2576,8 @@ impl FolderScanner {
// the emergency 250k ceiling. Keep FORCE as the absolute backstop.
let is_scan_root = folder.name == self.old_cache.info.name;
let forward_sweep = self.old_cache.info.scan_progress.is_some();
if let Some(reader) = &dir_reader {
reader.restore_abandoned(&mut abandoned_children);
}
let total_folders = dir_reader
.as_ref()
.and_then(ScannerDirectory::folder_count)
.unwrap_or(queued_folders.len());
// A completed root above the normal cache ceiling is compacted by
// the existing completion path. A resumable sorted listing can use
// that representation throughout processing without losing its place.
let emergency_compact = total_folders >= force_compaction_width();
let force_compact = emergency_compact || (indexed && total_folders > DATA_SCANNER_COMPACT_AT_CHILDREN);
let total_folders = queued_folders.len();
let force_compact = total_folders >= DATA_SCANNER_FORCE_COMPACT_AT_FOLDERS;
// Reused root children still have links in the new cache.
let should_compact = force_compact
|| (!forward_sweep
@@ -2818,7 +2586,7 @@ impl FolderScanner {
// Preserve the ordinary namespace walk's child isolation when the
// root starts sharing one accumulator across its descendants.
let isolate_compacted_children =
isolate_compacted_namespace_errors || (is_scan_root && !into.compacted && should_compact && !emergency_compact);
isolate_compacted_namespace_errors || (is_scan_root && !into.compacted && should_compact && !force_compact);
self.alert_excessive_folders(&folder.name, total_folders);
@@ -2835,7 +2603,7 @@ impl FolderScanner {
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_FOLDER,
folder = %folder.name,
entry_count = total_folders,
entry_count = queued_folders.len(),
state = "preemptive_compaction",
"Scanner folder switched to compacted mode"
);
@@ -2864,7 +2632,7 @@ impl FolderScanner {
.and_then(|resume_after| folder_resume_match(&folder.name, resume_after))
.is_some_and(|resume_match| matches!(resume_match, FolderResumeMatch::Descendant));
let scan_resume_after = checkpoint_resume_after.or(self.old_cache.info.scan_resume_after.as_deref());
let has_queued_folders = total_folders > 0;
let has_queued_folders = !queued_folders.is_empty();
let resume_order = if forward_sweep {
order_queued_folders_for_resume(&mut queued_folders, None)
} else {
@@ -2878,95 +2646,14 @@ impl FolderScanner {
}
}
let mut work = dir_reader.as_mut().and_then(ScannerDirectory::work);
if let Some(work) = &mut work {
work.restore_mode(into.compacted);
// A saved prefix tree must actually contain the contributions
// the parked queue has consumed. A failed cache save can leave
// this process's classified names ahead of its durable values.
if !into.compacted
&& !work
.linked
.iter()
.all(|name| self.can_restore_linked_child(&folder, into, name))
{
work.rewind();
}
self.coverage_gap |= work.gap;
if into.compacted {
into.merge(&work.compacted_total);
} else {
for name in &work.linked {
let child = hash_path(name);
self.new_cache
.copy_with_children(&self.old_cache, &child, &Some(this_hash.clone()));
into.add_child(&child);
}
}
}
let mut queued_folders = queued_folders.into_iter();
let mut acknowledge_previous: Option<(String, bool)> = None;
loop {
if let Some(work) = &mut work
&& let Some((name, linked)) = acknowledge_previous.take()
{
work.gap |= self.coverage_gap;
work.acknowledge(&name, linked, into.compacted);
}
// Scan child folders in the combined resume order.
for queued_folder in queued_folders {
if ctx.is_cancelled() {
return Err(ScannerError::Other("Operation cancelled".to_string()));
}
let queued_folder = if let Some(work) = &mut work {
let Some(name) = wait_for_scanner_io(
&ctx,
run_scanner_node_operation(self.node_admission.as_ref(), &ctx, work.next_name()),
)
.await???
else {
break;
};
let name = path_join_buf(&[&folder.name, &name]);
let source = if !force_compact && self.old_cache.find(&name).is_some() {
FolderScanSource::Existing
} else {
FolderScanSource::New
};
let h = hash_path(&name);
if source == FolderScanSource::Existing
&& let Some(updates) = &mut self.usage_updates
{
updates
.cache
.copy_with_children(&self.old_cache, &h, &Some(this_hash.clone()));
}
QueuedFolder {
folder: CachedFolder {
name,
parent: Some(this_hash.clone()),
object_heal_prob_div: folder.object_heal_prob_div,
},
source,
}
} else {
let Some(queued) = queued_folders.next() else { break };
queued
};
let mut folder_item = queued_folder.folder;
let h = hash_path(&folder_item.name);
if work.is_some() {
acknowledge_previous = Some((folder_item.name.clone(), false));
}
if work.is_some()
&& queued_folder.source == FolderScanSource::Existing
&& self.can_reuse_scoped_child(&folder, into, &folder_item.name, &h)
{
self.reuse_clean_root_child(&folder_item, &h, into);
if let Some((_, linked)) = &mut acknowledge_previous {
*linked = true;
}
continue;
}
let reuse_covered = self.can_reuse_covered_namespace(&folder_item.name, into.compacted);
let mut child_mode = if self.is_erasure_mode && is_erasure_candidate(&folder_item.name) {
FolderScanMode::ErasureCandidate {
@@ -2979,9 +2666,6 @@ impl FolderScanner {
if child_mode == FolderScanMode::Namespace && reuse_covered {
self.new_cache.copy_with_children(&self.old_cache, &h, &folder_item.parent);
into.add_child(&h);
if let Some((_, linked)) = &mut acknowledge_previous {
*linked = true;
}
continue;
}
@@ -3060,16 +2744,12 @@ impl FolderScanner {
// rolling back totals already committed by healthy siblings.
let isolate_compacted_child =
into.compacted && isolate_compacted_children && child_mode == FolderScanMode::Namespace;
// A parked queue owns only committed subtree totals. Run the
// active child in its own accumulator so cancellation cannot
// count a partial child twice at the next admission.
let child_summary = isolate_compacted_child || (into.compacted && work.is_some());
let outcome = if into.compacted && !child_summary {
let outcome = if into.compacted && !isolate_compacted_child {
// Keep the shared-accumulator path free of child summaries.
Box::pin(self.scan_folder_inner(ctx.clone(), folder_item.clone(), into, child_mode, false)).await?
} else {
let mut dst = DataUsageEntry {
compacted: child_summary,
compacted: isolate_compacted_child,
..Default::default()
};
// Provisional child usage must not escape through progress
@@ -3079,15 +2759,8 @@ impl FolderScanner {
} else {
None
};
let result = if child_summary {
Box::pin(self.scan_folder_inner(
ctx.clone(),
folder_item.clone(),
&mut dst,
child_mode,
isolate_compacted_child,
))
.await
let result = if isolate_compacted_child {
Box::pin(self.scan_folder_inner(ctx.clone(), folder_item.clone(), &mut dst, child_mode, true)).await
} else {
self.scan_child_folder(ctx.clone(), folder_item.clone(), &mut this_hash, into, &mut dst, child_mode)
.await
@@ -3097,22 +2770,14 @@ impl FolderScanner {
}
match result {
Ok(outcome) => {
if child_summary {
if isolate_compacted_child {
into.merge(&dst);
if let Some(work) = &mut work {
if outcome == FolderScanOutcome::Namespace && !self.coverage_gap && dst.failed_objects == 0 {
work.compacted_total.merge(&dst);
work.acknowledge(&folder_item.name, false, true);
} else if dst.failed_objects != 0 {
self.coverage_gap = true;
}
}
}
outcome
}
Err(e) => {
if ctx.is_cancelled() || matches!(&e, ScannerError::ResourceDeferred) {
if child_summary {
if isolate_compacted_child {
// Cancellation and resource deferral keep completed
// work even though the child has not finished.
into.merge(&dst);
@@ -3122,7 +2787,7 @@ impl FolderScanner {
}
return Err(e);
}
if child_mode != FolderScanMode::Namespace || (into.compacted && !isolate_compacted_child) {
if child_mode != FolderScanMode::Namespace {
return Err(e);
}
warn!(
@@ -3179,16 +2844,10 @@ impl FolderScanner {
}
if into.compacted {
self.record_completed_child(&folder_item.name);
if !was_compacted && work.is_some() {
self.maybe_send_owned_checkpoint(&folder, &this_hash, into, work.as_deref());
}
self.send_update_for_entry(&this_hash, &folder.parent, into).await;
tokio::task::yield_now().await;
} else {
into.add_child(&h);
if let Some(work) = &mut work {
work.acknowledge(&folder_item.name, true, false);
}
self.record_completed_child(&folder_item.name);
tokio::task::yield_now().await;
self.maybe_send_checkpoint(&folder, &this_hash, into);
@@ -3197,14 +2856,6 @@ impl FolderScanner {
}
}
if let Some(reader) = &mut dir_reader {
wait_for_scanner_io(
&ctx,
run_scanner_node_operation(self.node_admission.as_ref(), &ctx, reader.verify_current()),
)
.await???;
}
// Scan for healing
if abandoned_children.is_empty() || !self.should_heal().await {
debug!(
@@ -3683,7 +3334,6 @@ impl FolderScanner {
let scanned_objects = u64::try_from(into.objects).unwrap_or(u64::MAX);
emit_scanner_folder_trace(&self.root, &folder.name, scanned_objects, trace_started_at, "completed");
self.directory_checkpoints.remove(&folder.name);
Ok(FolderScanOutcome::Namespace)
}
@@ -3717,7 +3367,7 @@ pub(crate) async fn scan_data_folder_scoped(
budget: Arc<ScannerCycleBudget>,
disks: Vec<Arc<Disk>>,
local_disk: Arc<Disk>,
mut cache: DataUsageCache,
cache: DataUsageCache,
updates: Option<mpsc::Sender<DataUsageEntry>>,
scan_mode: HealScanMode,
sleeper: DynamicSleeper,
@@ -3731,19 +3381,6 @@ pub(crate) async fn scan_data_folder_scoped(
return Err(ScannerError::Other("internal error: root scan attempted".to_string()));
}
// URL endpoints include the storage host. A formatted disk also contributes
// its persistent UUID, fencing replacements and clone-like device/inode IDs.
if cache.info.scan_progress.is_some() && cache.info.scan_identity.is_some() {
use crate::storage_api::owner::EcstoreDiskAPI;
let endpoint = local_disk.endpoint().to_string();
let source = wait_for_scanner_io(&ctx, directory_cursor::physical_source(&local_disk)).await??;
let mut endpoints: HashSet<_> = disks.iter().map(|disk| disk.endpoint().to_string()).collect();
endpoints.insert(endpoint);
cache.activate_directory_source(source, &endpoints);
}
let directory_work = std::mem::take(&mut cache.info.scan_directory_work);
cache.info.scan_directory_work = DirectoryCheckpoint::verified_work(directory_work, &cache.info);
// Get disk path
let base_path = local_disk.path().to_string_lossy().to_string();
@@ -3800,16 +3437,6 @@ pub(crate) async fn scan_data_folder_scoped(
Vec::new()
};
// Create folder scanner
let mut directory_checkpoints = HashMap::new();
for checkpoint in &cache.info.scan_directory_work {
directory_checkpoints
.entry(checkpoint.parent().to_owned())
.or_insert_with(HashMap::new)
.insert(
checkpoint.endpoint().to_owned(),
Arc::new(std::sync::Mutex::new(Some(checkpoint.clone()))),
);
}
let mut scanner = FolderScanner {
root: base_path,
old_cache: cache,
@@ -3850,7 +3477,6 @@ pub(crate) async fn scan_data_folder_scoped(
resume_failed_paths,
coverage_gap: false,
raw_enumeration_progress: Vec::new(),
directory_checkpoints,
pending_size_reconciliation_keys: HashSet::new(),
pending_size_reconciliation_scopes: HashSet::new(),
pending_size_reconciliation_truncated: false,
@@ -3888,7 +3514,6 @@ pub(crate) async fn scan_data_folder_scoped(
.await
{
Ok(()) => {
directory_cursor::forget_bucket(&scanner.local_disk, &scanner.old_cache.info);
// Get the new cache and finalize it
let coverage_gap = scanner.coverage_gap;
scanner.reconcile_failed_objects_after_full_scan();
@@ -3933,9 +3558,6 @@ pub(crate) async fn scan_data_folder_scoped(
new_cache.info.scan_raw_enumeration_cursor = None;
new_cache.info.scan_raw_enumeration_page_index = None;
new_cache.info.scan_raw_enumeration_path_page_indexes.clear();
new_cache.info.scan_directory_work.clear();
new_cache.info.scan_directory_source = None;
new_cache.info.scan_source_trees.clear();
new_cache.info.scan_coverage_receipt = None;
if had_scan_checkpoint {
global_metrics().record_scanner_checkpoint_cleared();
@@ -3984,9 +3606,7 @@ pub(crate) async fn scan_data_folder_scoped(
scanner.carry_forward_old_children(&root_hash, &mut root);
}
let coverage_frontier = clone_cache_value(&scanner.coverage_frontier);
let directories = scanner.saved_directories();
let new_cache = scanner.as_mut_new_cache();
new_cache.info.scan_directory_work = directories;
if root_has_progress {
new_cache.replace_hashed(&root_hash, &None, &root);
} else if let Some(cache) = carry_forward_cache {
@@ -4006,7 +3626,6 @@ pub(crate) async fn scan_data_folder_scoped(
new_cache.info.scan_coverage_receipt = None;
}
if partial_cache_is_useful(&root, pending_heals_changed)
|| !new_cache.info.scan_directory_work.is_empty()
|| new_cache.info.scan_raw_enumeration_cursor.is_some()
|| new_cache.info.scan_raw_enumeration_page_index.is_some()
|| !new_cache.info.size_reconciliation.is_empty()
@@ -4082,9 +3701,6 @@ pub(crate) async fn scan_data_folder_scoped(
}
}
mod directory_cursor;
pub use directory_cursor::DirectoryCheckpoint;
pub(crate) use directory_cursor::{DirectoryProgress, DirectoryReadProgress};
mod item_actions;
mod ledger;
mod native_io;
@@ -1,719 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
//! Cycle-local execution can borrow an interrupted physical directory stream.
//! Only the current scanner owns admission and classification; parked streams
//! have no task, budget or authority to update a bucket cache.
use std::collections::HashMap;
mod checkpoint;
mod pages;
pub use checkpoint::DirectoryCheckpoint;
pub(super) use checkpoint::Saved;
pub(crate) use checkpoint::{DirectoryProgress, DirectoryReadProgress};
use checkpoint::{Physical, Recorder, Scope};
use pages::NamePages;
use std::io;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::sync::{Arc, LazyLock, Mutex, Weak};
use std::time::{Duration, Instant, SystemTime};
use super::{DirectoryStream, Disk, FolderScanMode, ScannerBucketPrefixScanScope, native_io};
use crate::data_usage_define::{DataUsageCacheInfo, DataUsageCacheSource, DataUsageScanIdentity, DataUsageScanProgress};
use crate::scanner_budget::ScannerCycleBudget;
pub(super) const PARKED_DIRECTORIES_PER_DISK: usize = 32;
/// Only a positively identified disk can re-adopt a linked tree. A missing
/// format on an otherwise visible local drive uses its directory generation;
/// genuine format I/O errors propagate before any cached subtotals are used.
pub(super) async fn physical_source(disk: &Arc<Disk>) -> Result<String, super::ScannerError> {
use crate::storage_api::owner::EcstoreDiskAPI;
use sha2::{Digest, Sha256};
let endpoint = disk.endpoint().to_string();
let generation = match disk.get_disk_id().await {
Ok(Some(id)) if !id.is_nil() => id.to_string(),
Ok(None) | Err(super::DiskError::UnformattedDisk) => {
let path = disk.path();
let stamp = DirectoryStamp::at(path.to_str().ok_or_else(|| io::Error::from(io::ErrorKind::InvalidInput))?).await?;
// Bucket creation and scanner startup can change the volume root's
// mtime/ctime. Birth time distinguishes inode reuse without making
// ordinary directory content changes appear to replace the disk.
if let Some(generation) = stamp.volume_generation() {
let bytes = rmp_serde::to_vec_named(&(std::env::consts::OS, generation)).map_err(io::Error::other)?;
hex_simd::encode_to_string(Sha256::digest(bytes), hex_simd::AsciiCase::Lower)
} else {
// The platform cannot attest the generation across processes.
uuid::Uuid::new_v4().to_string()
}
}
Ok(Some(_)) => return Err(io::Error::new(io::ErrorKind::InvalidData, "scanner disk format contains a nil ID").into()),
Err(error) => return Err(io::Error::other(error).into()),
};
Ok(format!("{generation}|{endpoint}"))
}
#[derive(Clone)]
pub(super) struct DirectoryScope {
disk: Weak<Disk>,
bucket: Arc<str>,
source: DataUsageCacheSource,
identity: DataUsageScanIdentity,
progress: DataUsageScanProgress,
mode: FolderScanMode,
prefix_scope: Option<ScannerBucketPrefixScanScope>,
owner: (u64, u64),
endpoint: String,
watch: Option<[u8; 32]>,
continuing: bool,
}
impl DirectoryScope {
pub(super) fn new(
disk: &Arc<Disk>,
cache: &super::DataUsageCache,
mode: FolderScanMode,
prefix_scope: Option<ScannerBucketPrefixScanScope>,
) -> Option<Self> {
use crate::storage_api::owner::EcstoreDiskAPI;
let info = &cache.info;
Some(Self {
disk: Arc::downgrade(disk),
bucket: Arc::from(info.name.as_str()),
source: info.source?,
identity: info.scan_identity.filter(DataUsageScanIdentity::is_valid)?,
progress: info.scan_progress?,
mode,
prefix_scope,
owner: (info.leader_epoch, info.next_cycle),
endpoint: format!("|{}", disk.endpoint()),
watch: info
.scan_usage_watch
.as_ref()
.filter(|proof| proof.is_well_formed())
.map(|proof| proof.digest().0),
continuing: cache.has_scan_position(),
})
}
pub(super) fn bind_source(&mut self, source: Option<&str>) {
if let Some(source) = source {
self.endpoint = source.to_owned();
}
}
pub(super) fn endpoint(&self) -> &str {
&self.endpoint
}
fn matches(&self, other: &Self) -> bool {
self.endpoint == other.endpoint
&& self.disk.ptr_eq(&other.disk)
&& self.bucket == other.bucket
&& self.source == other.source
&& self.identity == other.identity
&& self.progress == other.progress
&& self.mode == other.mode
&& self.watch == other.watch
&& self.prefix_scope == other.prefix_scope
&& (other.continuing || self.owner == other.owner)
}
}
#[derive(PartialEq, Eq)]
struct DirectoryStamp {
modified: SystemTime,
birth: Option<SystemTime>,
#[cfg(unix)]
device: u64,
#[cfg(unix)]
inode: u64,
#[cfg(unix)]
changed: (i64, i64),
#[cfg(windows)]
identity: same_file::Handle,
#[cfg(windows)]
physical: Option<(u64, u64, i64)>,
}
impl DirectoryStamp {
fn volume_generation(&self) -> Option<(u64, u64, SystemTime)> {
#[cfg(unix)]
{
Some((self.device, self.inode, self.birth?))
}
#[cfg(windows)]
{
let (volume, file, _) = self.physical?;
Some((volume, file, self.birth?))
}
#[cfg(not(any(unix, windows)))]
{
None
}
}
async fn at(path: &str) -> io::Result<Self> {
let path = PathBuf::from(path);
crate::storage_api::ecstore_spawn_blocking_with_resource_ownership(move || {
let meta = std::fs::symlink_metadata(&path)?;
if !meta.is_dir() {
return Err(io::ErrorKind::NotADirectory.into());
}
#[cfg(unix)]
use std::os::unix::fs::MetadataExt;
#[cfg(windows)]
let identity = same_file::Handle::from_path(&path)?;
#[cfg(windows)]
let physical = winapi_util::file::information(identity.as_file()).ok().and_then(|info| {
let created = i64::try_from(info.creation_time()?).ok()?;
(info.file_index() != 0).then_some((info.volume_serial_number(), info.file_index(), created))
});
Ok(Self {
modified: meta.modified()?,
birth: meta.created().ok(),
#[cfg(unix)]
device: meta.dev(),
#[cfg(unix)]
inode: meta.ino(),
#[cfg(unix)]
changed: (meta.ctime(), meta.ctime_nsec()),
#[cfg(windows)]
identity,
#[cfg(windows)]
physical,
})
})
.await
.map_err(io::Error::other)?
}
}
#[derive(Default)]
pub(super) struct DirectoryWork {
names: NamePages,
// For a prefix tree the canonical child values live in the bucket cache.
// The final compaction threshold caps how many paths this list can hold.
pub(super) linked: Vec<String>,
pub(super) compacted_total: super::DataUsageEntry,
pub(super) gap: bool,
compacted: bool,
recorder: Option<Recorder>,
}
impl DirectoryWork {
pub(super) fn restore_mode(&mut self, compacted: bool) {
if self.compacted && !compacted {
self.rewind();
}
}
fn maybe_checkpoint(&mut self) {
if let Some(recorder) = &mut self.recorder
&& recorder.last_update.elapsed() >= Duration::from_secs(1)
{
recorder.last_update = Instant::now();
self.checkpoint();
}
}
pub(super) fn checkpoint(&self) {
if let Some(recorder) = &self.recorder {
recorder.save(self);
}
}
pub(super) async fn next_name(&mut self) -> io::Result<Option<String>> {
self.names.next().await
}
pub(super) fn acknowledge(&mut self, name: &str, linked: bool, compacted: bool) {
if self.names.acknowledge() {
self.compacted = compacted;
if linked && !compacted {
self.linked.push(name.to_owned());
}
self.maybe_checkpoint();
}
}
pub(super) fn rewind(&mut self) {
self.compacted = false;
self.names.rewind();
self.linked.clear();
self.compacted_total = super::DataUsageEntry::default();
self.gap = false;
}
}
struct Listing {
reader: Option<DirectoryStream>,
pending: Option<native_io::DirEntry>,
delivery: Option<(native_io::DirEntry, bool)>,
classified: Option<Option<std::fs::FileType>>,
markers: [Option<native_io::DirEntry>; 2],
abandoned: Option<super::DataUsageHashMap>,
work: DirectoryWork,
failed: bool,
}
struct Parked {
scope: DirectoryScope,
parked_at: Instant,
serial: u64,
stamp: DirectoryStamp,
listing: Box<Listing>,
}
static PARKED: LazyLock<Mutex<HashMap<PathBuf, Parked>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
fn expired_slots(slots: &mut HashMap<PathBuf, Parked>) -> Vec<(PathBuf, Parked)> {
slots
.extract_if(|_, parked| {
parked.scope.disk.strong_count() == 0 || parked.parked_at.elapsed() > Duration::from_secs(24 * 3600)
})
.collect()
}
/// A routing hint only. The admitted walker revalidates the physical source,
/// bucket instance, coverage plan and directory before using a parked stream.
pub(crate) fn parked_bucket_disks(bucket: &str) -> Vec<Weak<Disk>> {
let mut slots = PARKED.lock().unwrap_or_else(|p| p.into_inner());
let expired = expired_slots(&mut slots);
let matches = slots
.values()
.filter(|entry| entry.scope.bucket.as_ref() == bucket)
.map(|entry| entry.scope.disk.clone())
.collect();
drop(slots);
drop(expired);
matches
}
pub(super) fn is_parked(path: &str) -> bool {
PARKED.lock().unwrap_or_else(|p| p.into_inner()).contains_key(Path::new(path))
}
pub(super) fn forget_bucket(disk: &Arc<Disk>, info: &DataUsageCacheInfo) {
let owner = Arc::downgrade(disk);
let mut slots = PARKED.lock().unwrap_or_else(|p| p.into_inner());
let removed = slots
.extract_if(|_, parked| {
parked.scope.disk.ptr_eq(&owner)
&& parked.scope.bucket.as_ref() == info.name
&& parked.scope.owner <= (info.leader_epoch, info.next_cycle)
})
.collect::<Vec<_>>();
drop(slots);
drop(removed);
}
// Prefer existing active work over cyclic LRU eviction. Under pressure, a
// deleted or replaced directory must not monopolize one of the physical slots.
async fn reclaim_retired(scope: &DirectoryScope, path: &Path) {
static NEXT_PROBE: AtomicUsize = AtomicUsize::new(0);
let candidate = {
let slots = PARKED.lock().unwrap_or_else(|p| p.into_inner());
if slots.contains_key(path) {
return;
}
let disk_slots: Vec<_> = slots
.iter()
.filter(|(_, parked)| parked.scope.disk.ptr_eq(&scope.disk))
.collect();
if disk_slots.len() < PARKED_DIRECTORIES_PER_DISK {
return;
}
let (path, parked) = disk_slots[NEXT_PROBE.fetch_add(1, Ordering::Relaxed) % disk_slots.len()];
(path.clone(), parked.serial)
};
let Some(candidate_path) = candidate.0.to_str() else { return };
let current = DirectoryStamp::at(candidate_path).await;
let mut slots = PARKED.lock().unwrap_or_else(|p| p.into_inner());
let stale = slots.get(&candidate.0).is_some_and(|parked| {
parked.serial == candidate.1
&& match &current {
Ok(stamp) => stamp != &parked.stamp,
Err(error) => matches!(error.kind(), io::ErrorKind::NotFound | io::ErrorKind::NotADirectory),
}
});
let retired = stale.then(|| slots.remove(&candidate.0));
drop(slots);
drop(retired);
}
fn valid_component(name: &str) -> bool {
!name.is_empty()
&& name.len() <= 4096
&& name != "."
&& name != ".."
&& !name.as_bytes().contains(&0)
&& std::path::Path::new(name)
.file_name()
.is_some_and(|part| part == std::ffi::OsStr::new(name))
}
pub(super) struct ScannerDirectory {
path: Arc<Path>,
scope: Option<(DirectoryScope, DirectoryStamp)>,
directory_name: Arc<str>,
budget: Arc<ScannerCycleBudget>,
listing: Option<Box<Listing>>,
marker: usize,
pub(super) enumeration_only: bool,
resumed: bool,
pub(super) directory_replaced: bool,
pub(super) batch_entries: usize,
}
impl ScannerDirectory {
pub(super) async fn open(
path: &str,
directory_name: &str,
scope: Option<DirectoryScope>,
budget: Arc<ScannerCycleBudget>,
saved: Option<Saved>,
) -> io::Result<Self> {
// A different physical directory must never inherit old names. Directory
// timestamps supplement (and cannot replace) the scanner's plan fences.
let stamp = if scope.is_some() {
Some(DirectoryStamp::at(path).await?)
} else {
None
};
if let Some(scope) = &scope {
reclaim_retired(scope, Path::new(path)).await;
}
let parked = scope.as_ref().and_then(|current| {
let mut slots = PARKED.lock().unwrap_or_else(|p| p.into_inner());
let key = Path::new(path);
if slots
.get(key)
.is_some_and(|p| p.scope.disk.ptr_eq(&current.disk) && p.scope.owner > current.owner)
{
return None;
}
slots.remove(key)
});
let directory_replaced = parked.as_ref().is_some_and(|entry| Some(&entry.stamp) != stamp.as_ref());
let parked =
parked.filter(|entry| !directory_replaced && scope.as_ref().is_some_and(|current| entry.scope.matches(current)));
let mut resumed = parked.is_some();
let mut previous = saved
.as_ref()
.and_then(|slot| slot.lock().unwrap_or_else(|p| p.into_inner()).clone());
let durable_scope = scope.as_ref().map(Scope::new);
let endpoint = scope.as_ref().map(|s| s.endpoint.clone()).unwrap_or_default();
let physical = scope
.as_ref()
.zip(stamp.as_ref())
.and_then(|(scope, stamp)| Physical::of(&scope.endpoint, stamp));
let mut replaced = directory_replaced
|| previous
.as_ref()
.is_some_and(|old| old.endpoint() == endpoint && old.physical.is_some() && old.physical != physical);
previous = previous.filter(|old| {
durable_scope
.as_ref()
.is_some_and(|current| old.restore_allowed(directory_name, current, &physical))
});
let mut listing = if let Some(parked) = parked {
parked.listing
} else {
let mut reader = None;
if let Some(checkpoint) = &previous {
if checkpoint.sealed {
resumed = true;
} else if let Some(anchor) = &checkpoint.anchor {
match DirectoryStream::open_at(path, anchor).await {
Ok(restored) => {
reader = Some(restored);
resumed = true;
}
Err(error)
if matches!(
error.kind(),
io::ErrorKind::InvalidData
| io::ErrorKind::Unsupported
| io::ErrorKind::NotFound
| io::ErrorKind::InvalidInput
) =>
{
previous = None;
replaced = true;
}
Err(error) => return Err(error),
}
}
}
if !resumed {
reader = Some(DirectoryStream::open(path, scope.is_some()).await?);
}
let mut work = DirectoryWork::default();
let mut markers = [None, None];
if let Some(saved) = &previous {
if resumed && let Some(owner) = &scope {
tracing::debug!(
event = super::EVENT_SCANNER_FOLDER_STATE,
component = super::LOG_COMPONENT_SCANNER,
subsystem = super::LOG_SUBSYSTEM_FOLDER,
state = "directory_checkpoint_restored",
bucket = %owner.bucket,
directory = directory_name,
disk = %endpoint,
leader_epoch = owner.owner.0,
cycle = owner.owner.1,
restore_mode = if saved.sealed { "sealed_membership" } else { "native_position" },
entries_read = saved.entries_read,
completed_through = saved.aggregate.as_ref().map(|aggregate| aggregate.through.as_str()),
"Restored directory checkpoint"
);
}
work.names = NamePages::restore(&saved.pages, saved.sealed, saved.aggregate.as_ref().map(|a| a.through.as_str()));
if let Some(aggregate) = &saved.aggregate {
work.compacted = true;
work.compacted_total = aggregate.value.clone();
}
let physical_path: Arc<Path> = Arc::from(Path::new(path));
if let Some(part) = &saved.part {
markers[0] = Some(native_io::DirEntry::recorded(physical_path.clone(), part.into(), None));
}
if saved.metadata {
markers[1] = Some(native_io::DirEntry::recorded(physical_path, super::STORAGE_FORMAT_FILE.into(), None));
}
}
Box::new(Listing {
reader,
pending: None,
delivery: None,
classified: None,
markers,
abandoned: None,
work,
failed: false,
})
};
if let (Some(slot), Some(durable_scope)) = (saved, durable_scope) {
if let Some(recorder) = &mut listing.work.recorder {
recorder.slot = slot;
} else {
let recorder = Recorder::new(slot, directory_name, durable_scope, endpoint, physical, previous.as_ref());
listing.work.recorder = Some(recorder);
}
}
Ok(Self {
path: Arc::from(Path::new(path)),
scope: scope.zip(stamp),
directory_name: Arc::from(directory_name),
budget,
listing: Some(listing),
marker: 0,
enumeration_only: false,
resumed,
directory_replaced: replaced,
batch_entries: 0,
})
}
pub(super) fn continues_stream(&self) -> bool {
self.resumed
}
pub(super) fn indexed(&self) -> bool {
self.scope.is_some()
}
pub(super) async fn verify_current(&mut self) -> io::Result<()> {
let Some((_, original)) = &self.scope else { return Ok(()) };
let path = self.path.to_str().ok_or(io::ErrorKind::InvalidInput)?;
let current = DirectoryStamp::at(path).await?;
if *original == current {
return Ok(());
}
if let Some(listing) = &mut self.listing {
listing.failed = true;
}
Err(io::Error::new(io::ErrorKind::Interrupted, "scanner directory changed during traversal"))
}
pub(super) fn folder_count(&self) -> Option<usize> {
self.indexed()
.then(|| self.listing.as_ref().map_or(0, |l| l.work.names.len()))
}
pub(super) fn finished_listing(&self) -> bool {
self.listing.as_ref().is_some_and(|l| l.work.names.ready())
}
pub(super) fn work(&mut self) -> Option<&mut DirectoryWork> {
if !self.indexed() {
return None;
}
self.listing.as_mut().map(|listing| &mut listing.work)
}
pub(super) fn resolve_abandoned(&mut self, path: &str) {
if let Some(abandoned) = self.listing.as_mut().and_then(|l| l.abandoned.as_mut()) {
abandoned.remove(path);
}
}
pub(super) fn hold_abandoned(&mut self, baseline: &mut super::DataUsageHashMap) {
if self.indexed()
&& let Some(listing) = &mut self.listing
&& listing.abandoned.is_none()
{
if !baseline.is_empty() && self.resumed {
// Cold restore carries classified members, not the previous
// process's transient unresolved heal candidates.
for page in listing.work.names.snapshot() {
for name in page.names() {
baseline.remove(&super::path_join_buf(&[&self.directory_name, name]));
}
}
}
listing.abandoned = Some(std::mem::take(baseline));
}
}
pub(super) fn restore_abandoned(&self, baseline: &mut super::DataUsageHashMap) {
if let Some(abandoned) = self.listing.as_ref().and_then(|listing| listing.abandoned.as_ref()) {
baseline.clone_from(abandoned);
}
}
pub(super) async fn peek_entry(&mut self) -> io::Result<Option<native_io::DirEntry>> {
if let Some((entry, enumeration_only)) = self.listing.as_ref().and_then(|listing| listing.delivery.as_ref()) {
self.enumeration_only = *enumeration_only;
return Ok(Some(entry.clone()));
}
let entry = self.next_entry().await?;
if let (Some(listing), Some(entry)) = (&mut self.listing, &entry) {
listing.delivery = Some((entry.clone(), self.enumeration_only));
}
Ok(entry)
}
pub(super) fn accept_entry(&mut self) {
let Some(listing) = &mut self.listing else { return };
let Some((entry, _)) = listing.delivery.take() else { return };
// Discovering a name can precede the I/O admission wait. Commit its
// classification and native position together only after admission;
// a cold retry then re-reads any name still pending on cancellation.
let Some(kind) = listing.classified.take() else { return };
let name = entry.file_name();
let text = name.to_string_lossy();
if let Some(state) = &mut listing.work.recorder {
state.anchor = entry.anchor().cloned();
state.entries_read = state.entries_read.saturating_add(1);
state.valid_names &= name.to_str().is_some_and(valid_component);
}
if let Some(kind) = kind {
let direct_part = kind.is_file() && super::is_erasure_part_name(&text);
if kind.is_dir() {
if let Some(abandoned) = &mut listing.abandoned
&& !abandoned.is_empty()
{
abandoned.remove(&super::path_join_buf(&[&self.directory_name, &text]));
}
listing.work.names.add(text.into_owned());
} else if direct_part {
if let Some(state) = &mut listing.work.recorder {
state.part.get_or_insert_with(|| text.to_string());
}
listing.markers[0].get_or_insert_with(|| native_io::DirEntry::recorded(self.path.clone(), name, Some(kind)));
} else if text == super::STORAGE_FORMAT_FILE {
if let Some(state) = &mut listing.work.recorder {
state.metadata = true;
}
listing.markers[1] = Some(native_io::DirEntry::recorded(self.path.clone(), name, Some(kind)));
}
}
listing.work.maybe_checkpoint();
}
async fn next_entry(&mut self) -> io::Result<Option<native_io::DirEntry>> {
let erasure_candidate = self
.scope
.as_ref()
.is_some_and(|(scope, _)| scope.mode != FolderScanMode::Namespace);
let indexed = self.indexed();
let listing = self
.listing
.as_mut()
.ok_or_else(|| io::Error::other("scanner directory already returned"))?;
self.enumeration_only = false;
if let Some(reader) = listing.reader.as_mut() {
if !indexed {
return reader.next_entry().await;
}
listing.work.names.flush_full().await?;
if listing.pending.is_none() {
listing.pending = match reader.next_entry().await {
Ok(entry) => entry,
Err(error) => {
listing.failed = true;
return Err(error);
}
};
}
if let Some(entry) = &listing.pending {
let kind = match entry.file_type().await {
Ok(kind) => Some(kind),
Err(error) if matches!(error.kind(), io::ErrorKind::NotFound | io::ErrorKind::TooManyLinks) => None,
Err(error) => {
listing.failed = true;
return Err(error);
}
};
let name = entry.file_name();
let text = name.to_string_lossy();
self.enumeration_only = kind.is_none_or(|kind| {
(!kind.is_symlink() || text == super::STORAGE_FORMAT_FILE)
&& !(erasure_candidate && kind.is_file() && super::is_erasure_part_name(&text))
});
listing.classified = Some(kind);
return Ok(listing.pending.take());
}
listing.reader = None;
listing.work.names.finish();
listing.work.maybe_checkpoint();
}
while self.marker < listing.markers.len() {
let marker = self.marker;
self.marker += 1;
if let Some(entry) = &listing.markers[marker] {
return Ok(Some(entry.clone()));
}
}
Ok(None)
}
}
impl Drop for ScannerDirectory {
fn drop(&mut self) {
let Some((scope, stamp)) = self.scope.take() else { return };
let Some(listing) = self.listing.take() else { return };
if listing.failed {
if let Some(recorder) = &listing.work.recorder {
*recorder.slot.lock().unwrap_or_else(|p| p.into_inner()) = None;
}
return;
}
// An owner cancellation can still persist a partial cache. Keep its
// last accepted native position while releasing the live reader.
listing.work.checkpoint();
if self.budget.reason().is_none() {
return;
}
let mut slots = PARKED.lock().unwrap_or_else(|p| p.into_inner());
let expired = expired_slots(&mut slots);
let key = self.path.to_path_buf();
let replaced = slots
.get(&key)
.is_some_and(|p| !p.scope.disk.ptr_eq(&scope.disk) || p.scope.owner < scope.owner)
.then(|| slots.remove(&key));
if slots.values().filter(|p| p.scope.disk.ptr_eq(&scope.disk)).count() < PARKED_DIRECTORIES_PER_DISK
&& let std::collections::hash_map::Entry::Vacant(slot) = slots.entry(key)
{
static NEXT_SERIAL: AtomicU64 = AtomicU64::new(0);
slot.insert(Parked {
scope,
parked_at: Instant::now(),
serial: NEXT_SERIAL.fetch_add(1, Ordering::Relaxed),
stamp,
listing,
});
}
drop(slots);
drop((expired, replaced));
}
}
@@ -1,364 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{Instant, SystemTime};
use super::{DirectoryScope, DirectoryStamp, DirectoryWork, FolderScanMode, native_io, pages::NamePage};
use crate::data_usage_define::{
DataUsageCacheInfo, DataUsageCacheSource, DataUsageEntry, DataUsageScanIdentity, DataUsageScanProgress,
};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub(super) struct Scope {
bucket: String,
source: DataUsageCacheSource,
identity: DataUsageScanIdentity,
progress: DataUsageScanProgress,
mode: u8,
prefixes: Option<[u8; 32]>,
watch: Option<[u8; 32]>,
}
impl Scope {
fn may_adopt(&self, current: &Self) -> bool {
self.bucket == current.bucket
&& self.source == current.source
&& self.identity == current.identity
&& self.mode == current.mode
&& self.prefixes == current.prefixes
&& self.progress.started_plan == current.progress.started_plan
&& ((self.progress == current.progress && self.watch == current.watch)
|| current.progress.started_plan != current.progress.requested_plan)
}
pub(super) fn new(owner: &DirectoryScope) -> Self {
let mode = match owner.mode {
FolderScanMode::Namespace => 0,
FolderScanMode::ErasureCandidate {
reuse_namespace,
parent_has_metadata,
} => 1 + u8::from(reuse_namespace) + 2 * u8::from(parent_has_metadata),
};
let prefixes = owner.prefix_scope.as_ref().map(|scope| {
let mut entries: Vec<_> = scope.selected_top_level_entries.iter().collect();
entries.sort_unstable();
let mut hash = Sha256::new();
for entry in entries {
hash.update(u64::try_from(entry.len()).unwrap_or(u64::MAX).to_le_bytes());
hash.update(entry.as_bytes());
}
hash.finalize().into()
});
Self {
bucket: owner.bucket.to_string(),
source: owner.source,
identity: owner.identity,
progress: owner.progress,
mode,
prefixes,
watch: owner.watch,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub(crate) struct Physical {
pub(crate) endpoint: String,
device: u64,
inode: u64,
changed: (i64, i64),
modified: SystemTime,
}
impl Physical {
#[cfg(unix)]
pub(super) fn of(endpoint: &str, stamp: &DirectoryStamp) -> Option<Self> {
Some(Self {
endpoint: endpoint.to_owned(),
device: stamp.device,
inode: stamp.inode,
changed: stamp.changed,
modified: stamp.modified,
})
}
#[cfg(windows)]
pub(super) fn of(endpoint: &str, stamp: &DirectoryStamp) -> Option<Self> {
let (device, inode, created) = stamp.physical?;
Some(Self {
endpoint: endpoint.to_owned(),
device,
inode,
changed: (created, 0),
modified: stamp.modified,
})
}
#[cfg(not(any(unix, windows)))]
pub(super) fn of(_endpoint: &str, _stamp: &DirectoryStamp) -> Option<Self> {
None
}
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub(super) struct Aggregate {
pub(super) through: String,
pub(super) value: DataUsageEntry,
}
/// Immutable directory membership and the last fully counted compacted child.
/// The active child's provisional contribution is never part of this receipt.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DirectoryCheckpoint {
version: u8,
pub(super) parent: String,
scope: Scope,
pub(super) physical: Option<Physical>,
pub(super) pages: Vec<NamePage>,
pub(super) anchor: Option<native_io::DirectoryAnchor>,
pub(super) entries_read: u64,
pub(super) sealed: bool,
pub(super) part: Option<String>,
pub(super) metadata: bool,
pub(super) aggregate: Option<Aggregate>,
endpoint: String,
digest: [u8; 32],
}
/// Physical progress orders only callbacks from the same directory generation.
/// The coordinator uses these receipts for fair scheduling, never for coverage.
#[derive(Clone, Debug)]
pub(crate) struct DirectoryReadProgress {
pub(crate) parent: String,
pub(crate) physical: Physical,
position: (u64, bool),
}
impl DirectoryReadProgress {
pub(crate) fn same_source(&self, other: &Self) -> bool {
self.parent == other.parent && self.physical == other.physical
}
pub(crate) fn extends(&self, older: &Self) -> bool {
self.same_source(older) && self.position >= older.position
}
}
#[derive(Clone, Debug)]
pub(crate) struct DirectoryProgress {
pub(crate) parent: String,
pub(crate) physical: Physical,
manifest: [u8; 32],
through: String,
}
impl DirectoryProgress {
pub(crate) fn same_source(&self, previous: &Self) -> bool {
self.parent == previous.parent && self.physical == previous.physical && self.manifest == previous.manifest
}
pub(crate) fn extends(&self, previous: &Self) -> bool {
self.same_source(previous) && self.through >= previous.through
}
pub(crate) fn covers(&self, path: &str) -> bool {
path.strip_prefix(&self.parent)
.and_then(|tail| tail.strip_prefix('/'))
.and_then(|tail| tail.split('/').next())
.is_some_and(|child| child <= self.through.as_str())
}
}
impl DirectoryCheckpoint {
/// Deserialize each replica's independent receipt, then intern equal
/// verified immutable name pages across the bucket's active directories.
pub(crate) fn verified_work(work: Vec<Self>, info: &DataUsageCacheInfo) -> Vec<Self> {
let mut shared = HashMap::new();
work.into_iter()
.filter(|receipt| receipt.is_bound_to(info))
.map(|mut receipt| {
for page in &mut receipt.pages {
let canonical = shared.entry(*page.digest()).or_insert_with(|| page.clone());
*page = canonical.clone();
}
receipt
})
.collect()
}
pub(crate) fn parent(&self) -> &str {
&self.parent
}
pub(super) fn manifest(&self) -> [u8; 32] {
let mut hash = Sha256::new();
for p in &self.pages {
hash.update(p.digest());
}
hash.finalize().into()
}
fn checksum(&self) -> Option<[u8; 32]> {
// Nested usage distributions can contain maps. Canonicalize those
// map keys before hashing so restart hash randomization is irrelevant.
let mut aggregate = serde_json::to_value(&self.aggregate).ok()?;
aggregate.sort_all_objects();
let header = rmp_serde::to_vec_named(&(
self.version,
&self.parent,
&self.scope,
&self.physical,
&self.anchor,
self.entries_read,
self.sealed,
&self.part,
self.metadata,
self.manifest(),
aggregate,
&self.endpoint,
))
.ok()?;
Some(Sha256::digest(header).into())
}
pub(crate) fn is_bound_to(&self, info: &DataUsageCacheInfo) -> bool {
self.version == 1
&& self.scope.bucket == info.name
&& self.scope.identity.is_valid()
&& Some(self.scope.identity) == info.scan_identity
&& Some(self.scope.source) == info.source
&& info
.scan_progress
.is_some_and(|p| p.started_plan == self.scope.progress.started_plan)
&& (self.parent == info.name
|| self
.parent
.strip_prefix(&info.name)
.and_then(|p| p.strip_prefix('/'))
.is_some_and(|tail| tail.split('/').all(super::valid_component)))
&& self.valid_payload()
}
pub(crate) fn read_progress(&self, info: &DataUsageCacheInfo) -> Option<DirectoryReadProgress> {
let physical = self.physical.as_ref()?;
(self.is_bound_to(info) && (self.sealed || self.anchor.is_some()) && self.entries_read > 0).then(|| {
DirectoryReadProgress {
parent: self.parent.clone(),
physical: physical.clone(),
position: (self.entries_read, self.sealed),
}
})
}
pub(crate) fn progress(&self, info: &DataUsageCacheInfo) -> Option<DirectoryProgress> {
let done = self.aggregate.as_ref()?;
let physical = self.physical.as_ref()?;
(self.sealed && self.is_bound_to(info)).then(|| DirectoryProgress {
parent: self.parent.clone(),
physical: physical.clone(),
manifest: self.manifest(),
through: done.through.clone(),
})
}
pub(crate) fn endpoint(&self) -> &str {
&self.endpoint
}
fn valid_for(&self, parent: &str, owner: &Scope) -> bool {
self.version == 1 && self.parent == parent && self.scope.may_adopt(owner) && self.valid_payload()
}
fn valid_payload(&self) -> bool {
self.physical.as_ref().is_some_and(|source| source.endpoint == self.endpoint)
&& (self.sealed || self.anchor.is_some())
&& self.checksum() == Some(self.digest)
&& self.pages.iter().all(NamePage::valid)
&& self.part.as_deref().is_none_or(super::super::is_erasure_part_name)
&& self.aggregate.as_ref().is_none_or(|done| {
self.sealed
&& super::valid_component(&done.through)
&& done.value.children.is_empty()
&& done.value.failed_objects == 0
&& self.pages.iter().any(|page| page.contains(&done.through))
})
}
pub(super) fn restore_allowed(&self, parent: &str, owner: &Scope, physical: &Option<Physical>) -> bool {
self.valid_for(parent, owner)
&& self.physical.is_some()
&& &self.physical == physical
&& (self.sealed || self.anchor.is_some())
}
}
pub(in crate::scanner_folder) type Saved = Arc<Mutex<Option<DirectoryCheckpoint>>>;
pub(super) struct Recorder {
pub(super) slot: Saved,
scope: Scope,
parent: String,
physical: Option<Physical>,
pub(super) anchor: Option<native_io::DirectoryAnchor>,
pub(super) entries_read: u64,
pub(super) part: Option<String>,
pub(super) metadata: bool,
pub(super) valid_names: bool,
endpoint: String,
pub(super) last_update: Instant,
}
impl Recorder {
pub(super) fn new(
slot: Saved,
parent: &str,
scope: Scope,
endpoint: String,
physical: Option<Physical>,
previous: Option<&DirectoryCheckpoint>,
) -> Self {
Self {
slot,
scope,
parent: parent.to_owned(),
physical,
endpoint,
anchor: previous.and_then(|p| p.anchor.clone()),
entries_read: previous.map_or(0, |p| p.entries_read),
part: previous.and_then(|p| p.part.clone()),
metadata: previous.is_some_and(|p| p.metadata),
valid_names: true,
last_update: Instant::now(),
}
}
pub(super) fn save(&self, work: &DirectoryWork) {
// An ordinary object directory is cheaper to reopen. Only a reader
// which can actually resume or a closed directory can be checkpointed.
let sealed = work.names.ready();
let aggregate = if work.compacted && !work.gap {
work.names.through().map(|through| Aggregate {
through: through.to_owned(),
value: work.compacted_total.clone(),
})
} else {
None
};
let snapshot = if self.valid_names
&& self.physical.as_ref().is_some_and(|source| source.endpoint == self.endpoint)
&& (sealed || self.anchor.is_some())
{
let mut checkpoint = DirectoryCheckpoint {
version: 1,
parent: self.parent.clone(),
scope: self.scope.clone(),
physical: self.physical.clone(),
anchor: (!sealed).then(|| self.anchor.clone()).flatten(),
entries_read: self.entries_read,
pages: work.names.snapshot(),
sealed,
part: self.part.clone(),
metadata: self.metadata,
aggregate,
endpoint: self.endpoint.clone(),
digest: [0; 32],
};
checkpoint.checksum().map(|digest| {
checkpoint.digest = digest;
checkpoint
})
} else {
None
};
*self.slot.lock().unwrap_or_else(|p| p.into_inner()) = snapshot;
}
}
#[cfg(test)]
mod storage_fixture;
@@ -1,48 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
impl DirectoryCheckpoint {
pub(crate) async fn wide_storage_fixture(info: &DataUsageCacheInfo) -> [Self; 2] {
let scope = Scope {
bucket: info.name.clone(),
source: info.source.expect("fixture source"),
identity: info.scan_identity.expect("fixture identity"),
progress: info.scan_progress.expect("fixture coverage plan"),
mode: 0,
prefixes: None,
watch: None,
};
let slot = Saved::default();
let endpoint = info.scan_directory_source.clone().expect("fixture physical source");
let physical = Physical {
endpoint: endpoint.clone(),
device: 1,
inode: 2,
changed: (123, 0),
modified: SystemTime::UNIX_EPOCH,
};
let mut recorder = Recorder::new(slot.clone(), &info.name, scope, endpoint, Some(physical), None);
recorder.entries_read = 300_000;
let mut work = DirectoryWork {
compacted: true,
..Default::default()
};
for i in 0..300_000 {
work.names.add(format!("obj-{i:06}"));
work.names.flush_full().await.expect("record real immutable name page");
}
work.names.finish();
[121_034, 121_035].map(|objects| {
work.names.seek_after(Some(&format!("obj-{:06}", objects - 1)));
work.compacted_total.objects = objects;
work.compacted_total.size = objects * 1024;
recorder.save(&work);
slot.lock()
.expect("fixture slot")
.take()
.expect("sealed directory checkpoint")
})
}
}
@@ -1,290 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use std::cmp::Reverse;
use std::collections::BinaryHeap;
use std::io;
use std::sync::{Arc, OnceLock};
use serde::{Deserialize, Serialize};
use sha2::{Digest, Sha256};
const PAGE_NAMES: usize = 256;
const PAGE_NAME_BYTES: usize = 32 * 1024;
/// One contiguous UTF-8 string per run. Names from the filesystem cannot
/// contain NUL. Checkpoint clones share both the payload and its local index.
#[derive(Clone, Debug, Serialize, Deserialize)]
#[serde(transparent)]
pub(super) struct NamePage(Arc<PackedNames>);
#[derive(Debug, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
struct PackedNames {
text: Box<str>,
digest: [u8; 32],
#[serde(skip)]
starts: OnceLock<Box<[usize]>>,
#[serde(skip)]
valid: OnceLock<bool>,
}
impl NamePage {
fn hash(text: &str) -> [u8; 32] {
Sha256::new()
.chain_update(b"rustfs-scanner-directory-names-v1")
.chain_update(text.as_bytes())
.finalize()
.into()
}
fn new(mut names: Vec<String>) -> Self {
names.sort_unstable();
let mut text = String::with_capacity(names.iter().map(|n| n.len() + 1).sum());
for name in names {
text.push_str(&name);
text.push('\0');
}
Self(Arc::new(PackedNames {
digest: Self::hash(&text),
text: text.into_boxed_str(),
starts: OnceLock::new(),
valid: OnceLock::new(),
}))
}
fn starts(&self) -> &[usize] {
self.0.starts.get_or_init(|| {
self.names()
.scan(0, |offset, name| {
let start = *offset;
*offset += name.len() + 1;
Some(start)
})
.collect()
})
}
fn at(&self, offset: usize) -> &str {
self.0.text[offset..].split('\0').next().unwrap_or_default()
}
fn get(&self, index: usize) -> Option<&str> {
self.starts().get(index).map(|&offset| self.at(offset))
}
fn after(&self, last: &str) -> usize {
self.starts().partition_point(|&offset| self.at(offset) <= last)
}
pub(super) fn contains(&self, name: &str) -> bool {
self.starts().binary_search_by(|&offset| self.at(offset).cmp(name)).is_ok()
}
pub(super) fn digest(&self) -> &[u8; 32] {
&self.0.digest
}
pub(super) fn names(&self) -> impl Iterator<Item = &str> {
self.0.text.split_terminator('\0')
}
pub(super) fn valid(&self) -> bool {
*self.0.valid.get_or_init(|| {
let text = &self.0.text;
text.ends_with('\0')
&& text.len() <= PAGE_NAME_BYTES + PAGE_NAMES + 4096
&& self.names().take(PAGE_NAMES + 1).count() <= PAGE_NAMES
&& self.names().all(super::valid_component)
&& self.names().is_sorted()
&& self.0.digest == Self::hash(text)
})
}
}
/// Immutable sorted runs are shared with checkpoint snapshots. The merge
/// retains one head per run. At a cold resume each run seeks to the first
/// name after the authenticated completed child using binary search.
#[derive(Default)]
pub(super) struct NamePages {
pages: Vec<NamePage>,
building: Vec<String>,
name_bytes: usize,
count: usize,
heads: BinaryHeap<Reverse<(String, usize, usize)>>,
ready: bool,
pending: Option<String>,
through: Option<String>,
}
impl NamePages {
pub(super) fn len(&self) -> usize {
self.count
}
pub(super) fn ready(&self) -> bool {
self.ready
}
pub(super) fn through(&self) -> Option<&str> {
self.through.as_deref()
}
pub(super) fn add(&mut self, name: String) {
self.name_bytes = self.name_bytes.saturating_add(name.len());
self.count = self.count.saturating_add(1);
self.building.push(name);
}
fn flush(&mut self) {
if self.building.is_empty() {
return;
}
let page = NamePage::new(std::mem::take(&mut self.building));
if let Some(first) = page.get(0) {
self.heads.push(Reverse((first.to_owned(), self.pages.len(), 0)));
}
self.pages.push(page);
self.name_bytes = 0;
}
pub(super) async fn flush_full(&mut self) -> io::Result<()> {
if self.building.len() >= PAGE_NAMES || self.name_bytes >= PAGE_NAME_BYTES {
self.flush();
}
Ok(())
}
pub(super) fn finish(&mut self) {
self.flush();
self.ready = true;
}
pub(super) fn snapshot(&self) -> Vec<NamePage> {
let mut pages = self.pages.clone();
if !self.building.is_empty() {
pages.push(NamePage::new(self.building.clone()));
}
pages
}
pub(super) fn restore(pages: &[NamePage], ready: bool, through: Option<&str>) -> Self {
let mut names = Self {
pages: pages.to_vec(),
count: pages.iter().map(|p| p.starts().len()).sum(),
ready,
..Self::default()
};
if !ready
&& names
.pages
.last()
.is_some_and(|page| page.starts().len() < PAGE_NAMES && page.0.text.len() < PAGE_NAME_BYTES)
&& let Some(page) = names.pages.pop()
{
names.building = page.names().map(str::to_owned).collect();
names.name_bytes = names.building.iter().map(String::len).sum();
}
names.seek_after(through);
names
}
pub(super) fn seek_after(&mut self, through: Option<&str>) {
self.pending = None;
self.through = through.map(str::to_owned);
self.heads.clear();
for (page_index, page) in self.pages.iter().enumerate() {
let start = through.map_or(0, |last| page.after(last));
if let Some(next) = page.get(start) {
self.heads.push(Reverse((next.to_owned(), page_index, start)));
}
}
}
pub(super) fn rewind(&mut self) {
self.seek_after(None);
}
pub(super) async fn next(&mut self) -> io::Result<Option<String>> {
if self.pending.is_some() {
return Ok(self.pending.clone());
}
while let Some(Reverse((name, page, index))) = self.heads.pop() {
if let Some(next) = self.pages[page].get(index + 1) {
self.heads.push(Reverse((next.to_owned(), page, index + 1)));
}
if self.through.as_ref() == Some(&name) {
continue;
}
self.pending = Some(name.clone());
return Ok(Some(name));
}
Ok(None)
}
pub(super) fn acknowledge(&mut self) -> bool {
if let Some(name) = self.pending.take() {
self.through = Some(name);
return true;
}
false
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn packed_membership_shares_names_and_rejects_corrupt_payloads() {
let page = NamePage::new((0..PAGE_NAMES).rev().map(|i| format!("obj-{i:06}")).collect());
assert!(page.valid());
let shared = page.clone();
assert!(Arc::ptr_eq(&page.0, &shared.0));
let encoded = rmp_serde::to_vec_named(&page).expect("serialize packed names");
assert!(encoded.len() < PAGE_NAMES * 12, "checkpoint stores one delimited string per page");
let restored: NamePage = rmp_serde::from_slice(&encoded).expect("cold name page");
assert!(restored.valid());
assert!(restored.contains("obj-000137"));
assert_eq!(restored.get(restored.after("obj-000137")), Some("obj-000138"));
for text in ["", "obj", "a\0\0b\0", "b\0a\0", "../other\0"] {
let malformed = NamePage(Arc::new(PackedNames {
text: text.into(),
digest: NamePage::hash(text),
starts: OnceLock::new(),
valid: OnceLock::new(),
}));
assert!(!malformed.valid(), "invalid membership accepted: {text:?}");
}
let mut bytes = encoded;
let offset = bytes
.windows(10)
.position(|value| value == b"obj-000137")
.expect("encoded name");
bytes[offset] = b'x';
assert!(!rmp_serde::from_slice::<NamePage>(&bytes).expect("decodable payload").valid());
}
#[tokio::test]
async fn interleaved_pages_resume_at_each_unacknowledged_name() {
let mut pages = NamePages::default();
let mut expected = std::collections::BTreeSet::new();
// Each consecutive sorted run interleaves with every other run. One
// duplicate straddles two runs and a partial run remains in memory.
for run in 0..5 {
for index in (0..PAGE_NAMES).rev() {
let name = format!("item-{index:04}-{run:02}");
expected.insert(name.clone());
pages.add(name);
pages.flush_full().await.expect("append sorted run");
}
}
pages.add("item-0000-02".to_owned());
pages.finish();
for name in &expected {
assert_eq!(pages.next().await.expect("scheduled child").as_ref(), Some(name));
assert_eq!(pages.next().await.expect("retry after cancellation").as_ref(), Some(name));
assert!(pages.acknowledge());
}
assert_eq!(pages.next().await.expect("sealed EOF"), None);
pages.rewind();
assert_eq!(pages.next().await.expect("fresh coverage").as_ref(), expected.first());
}
}
+20 -223
View File
@@ -8,7 +8,7 @@ use std::ffi::OsString;
use std::fs::{FileType, Metadata};
use std::future::{Future, poll_fn};
use std::io;
use std::path::{Path, PathBuf};
use std::path::PathBuf;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Context, Poll, ready};
@@ -18,156 +18,31 @@ use crate::storage_api::ecstore_spawn_blocking_with_resource_ownership as spawn_
// Keep Tokio's existing bounded prefetch and one native job per refill.
const DIRECTORY_CHUNK_SIZE: usize = 32;
#[cfg(any(target_os = "linux", target_os = "macos"))]
mod positioned;
/// Identifies a verified prefix of a physical directory buffer. Only the
/// matching directory generation can use its platform-specific kernel cookie.
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct DirectoryAnchor {
directory: [u8; 32],
cookie: u64,
entries: u32,
prefix: [u8; 32],
}
#[derive(Clone)]
pub(super) struct DirEntry {
source: EntrySource,
entry: Arc<std::fs::DirEntry>,
file_type: Option<FileType>,
}
#[derive(Clone)]
enum EntrySource {
Native(Arc<std::fs::DirEntry>),
#[cfg(any(target_os = "linux", target_os = "macos"))]
Positioned(Arc<PositionedEntry>),
Recorded {
parent: Arc<std::path::Path>,
name: OsString,
},
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
#[derive(Clone)]
struct PositionedEntry {
parent: Arc<Path>,
name: OsString,
anchor: Option<DirectoryAnchor>,
}
impl DirEntry {
pub(super) fn recorded(parent: Arc<std::path::Path>, name: OsString, file_type: Option<FileType>) -> Self {
Self {
source: EntrySource::Recorded { parent, name },
file_type,
}
}
pub(super) fn anchor(&self) -> Option<&DirectoryAnchor> {
match &self.source {
#[cfg(any(target_os = "linux", target_os = "macos"))]
EntrySource::Positioned(entry) => entry.anchor.as_ref(),
_ => None,
}
}
#[cfg(test)]
pub(super) fn without_anchor(self) -> Self {
#[cfg(any(target_os = "linux", target_os = "macos"))]
{
let mut entry = self;
if let EntrySource::Positioned(position) = &mut entry.source {
Arc::make_mut(position).anchor = None;
}
entry
}
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
self
}
pub(super) fn is_recorded(&self) -> bool {
matches!(&self.source, EntrySource::Recorded { .. })
}
pub(super) fn cached_type(&self) -> Option<FileType> {
self.file_type
}
pub(super) fn path(&self) -> PathBuf {
match &self.source {
EntrySource::Native(entry) => entry.path(),
#[cfg(any(target_os = "linux", target_os = "macos"))]
EntrySource::Positioned(entry) => entry.parent.join(&entry.name),
EntrySource::Recorded { parent, name } => parent.join(name),
}
self.entry.path()
}
pub(super) fn file_name(&self) -> OsString {
match &self.source {
EntrySource::Native(entry) => entry.file_name(),
#[cfg(any(target_os = "linux", target_os = "macos"))]
EntrySource::Positioned(entry) => entry.name.clone(),
EntrySource::Recorded { name, .. } => name.clone(),
}
self.entry.file_name()
}
pub(super) async fn file_type(&self) -> io::Result<FileType> {
if let Some(file_type) = self.file_type {
return Ok(file_type);
}
match &self.source {
EntrySource::Native(entry) => {
let entry = entry.clone();
spawn_native(move || entry.file_type()).await.map_err(io::Error::other)?
}
_ => {
let path = self.path();
spawn_native(move || std::fs::symlink_metadata(path).map(|meta| meta.file_type()))
.await
.map_err(io::Error::other)?
}
}
}
}
enum PhysicalReader {
Standard(std::fs::ReadDir),
#[cfg(any(target_os = "linux", target_os = "macos"))]
Positioned(Box<positioned::Reader>),
}
impl PhysicalReader {
fn open(path: &Path, indexed: bool, anchor: Option<&DirectoryAnchor>) -> io::Result<Self> {
#[cfg(any(target_os = "linux", target_os = "macos"))]
if indexed {
return positioned::Reader::open(path, anchor).map(Box::new).map(Self::Positioned);
}
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
let _ = indexed;
if anchor.is_some() {
return Err(io::ErrorKind::Unsupported.into());
}
std::fs::read_dir(path).map(Self::Standard)
}
fn next(&mut self) -> Option<io::Result<DirEntry>> {
match self {
Self::Standard(reader) => reader.next().map(|entry| {
entry.map(|entry| DirEntry {
file_type: entry.file_type().ok(),
source: EntrySource::Native(Arc::new(entry)),
})
}),
#[cfg(any(target_os = "linux", target_os = "macos"))]
Self::Positioned(reader) => reader.next(),
}
let entry = self.entry.clone();
spawn_native(move || entry.file_type()).await.map_err(io::Error::other)?
}
}
struct DirectoryBuffer {
reader: PhysicalReader,
reader: std::fs::ReadDir,
entries: VecDeque<io::Result<DirEntry>>,
more: bool,
}
@@ -180,7 +55,10 @@ impl DirectoryBuffer {
break;
};
let success = entry.is_ok();
self.entries.push_back(entry);
self.entries.push_back(entry.map(|entry| DirEntry {
file_type: entry.file_type().ok(),
entry: Arc::new(entry),
}));
if !success {
break;
}
@@ -196,26 +74,14 @@ enum DirectoryState {
pub(super) struct ReadDir {
state: DirectoryState,
#[cfg(test)]
slow_directory: bool,
}
impl ReadDir {
pub(super) async fn open(path: &str, indexed: bool) -> io::Result<Self> {
Self::open_directory(path, indexed, None).await
}
pub(super) async fn open_at(path: &str, anchor: &DirectoryAnchor) -> io::Result<Self> {
Self::open_directory(path, true, Some(anchor.clone())).await
}
async fn open_directory(path: &str, indexed: bool, anchor: Option<DirectoryAnchor>) -> io::Result<Self> {
#[cfg(test)]
let slow_directory = super::tests::fair_prefix_quantum::is_slow_directory(path);
pub(super) async fn open(path: &str) -> io::Result<Self> {
let path = PathBuf::from(path);
let buffer = spawn_native(move || {
let mut buffer = DirectoryBuffer {
reader: PhysicalReader::open(&path, indexed, anchor.as_ref())?,
reader: std::fs::read_dir(path)?,
entries: VecDeque::with_capacity(DIRECTORY_CHUNK_SIZE),
more: true,
};
@@ -226,18 +92,12 @@ impl ReadDir {
.map_err(io::Error::other)??;
Ok(Self {
state: DirectoryState::Idle(Some(buffer)),
#[cfg(test)]
slow_directory,
})
}
pub(super) async fn next_entry(&mut self) -> io::Result<Option<DirEntry>> {
// Keep a pending refill on the reader, not in the borrowed next-entry
// future. Cancelling that future must not skip its prefetched entries.
#[cfg(test)]
if self.slow_directory {
super::tests::fair_prefix_quantum::charge_physical_read().await;
}
poll_fn(|cx| self.poll_next_entry(cx)).await
}
@@ -341,7 +201,7 @@ mod tests {
Resources::Layered(owner.capture(&units.iter().collect::<Vec<_>>()).expect("native ownership"))
};
drop(units);
let mut reader = ReadDir::open(path, false).await.expect("prepare reader");
let mut reader = ReadDir::open(path).await.expect("prepare reader");
let mut entry = reader.next_entry().await.expect("first entry").expect("file");
entry.file_type = None;
for _ in 1..DIRECTORY_CHUNK_SIZE {
@@ -350,7 +210,7 @@ mod tests {
let (release, blocker) = occupy_native_worker().await;
let work = async {
match operation {
"open" => ReadDir::open(path, false).await.map(|_| ()),
"open" => ReadDir::open(path).await.map(|_| ()),
"refill" => reader.next_entry().await.map(|_| ()),
"metadata" => metadata(entry.path().to_str().expect("entry path")).await.map(|_| ()),
"file_type" => entry.file_type().await.map(|_| ()),
@@ -393,9 +253,7 @@ mod tests {
runtime().block_on(async {
let count = DIRECTORY_CHUNK_SIZE * 3 + 7;
let root = directory(count);
let mut reader = ReadDir::open(root.path().to_str().expect("root path"), false)
.await
.expect("open");
let mut reader = ReadDir::open(root.path().to_str().expect("root path")).await.expect("open");
let mut names = std::collections::BTreeSet::new();
for _ in 0..DIRECTORY_CHUNK_SIZE {
let entry = reader.next_entry().await.expect("entry").expect("file");
@@ -415,71 +273,12 @@ mod tests {
});
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
#[test]
fn reopened_directory_matches_original_suffix_and_rejects_stale_or_corrupt_positions() {
runtime().block_on(async {
#[cfg(target_os = "linux")]
use std::os::unix::ffi::OsStrExt;
let root = directory(900);
let path = root.path().to_str().expect("root path");
#[cfg(target_os = "linux")]
let raw_name = std::ffi::OsStr::from_bytes(b"object-\xff");
// APFS requires filenames that are valid Unicode.
#[cfg(target_os = "macos")]
let raw_name = std::ffi::OsStr::new("object-目录");
std::fs::write(root.path().join(raw_name), []).expect("platform-native directory entry");
let mut reader = ReadDir::open(path, true).await.expect("open indexed directory");
let mut names = Vec::new();
let mut anchors = Vec::new();
while let Some(entry) = reader.next_entry().await.expect("read indexed entry") {
assert!(!entry.is_recorded());
names.push(entry.file_name());
anchors.push(entry.anchor().expect("native directory position").clone());
}
drop(reader);
assert!(names.iter().any(|name| name == raw_name));
assert!(anchors.iter().any(|anchor| anchor.cookie != 0), "exercise a later kernel buffer");
for i in [0, 32, 145, 419, names.len() - 1] {
let mut resumed = ReadDir::open_at(path, &anchors[i])
.await
.expect("reopen directory at verified entry");
for expected in &names[i + 1..] {
assert_eq!(
&resumed
.next_entry()
.await
.expect("suffix read")
.expect("suffix entry")
.file_name(),
expected
);
}
assert!(resumed.next_entry().await.expect("resumed EOF").is_none());
}
let mut corrupt = anchors[0].clone();
corrupt.prefix[0] ^= 1;
assert!(matches!(ReadDir::open_at(path, &corrupt).await, Err(err) if err.kind() == io::ErrorKind::InvalidData));
corrupt.entries = u32::MAX;
assert!(matches!(ReadDir::open_at(path, &corrupt).await, Err(err) if err.kind() == io::ErrorKind::InvalidData));
let other = directory(1);
let another = other.path().to_str().expect("other directory");
assert!(matches!(ReadDir::open_at(another, &anchors[0]).await, Err(err) if err.kind() == io::ErrorKind::InvalidData));
// Removing the bound entry also invalidates its directory generation.
std::fs::remove_file(root.path().join(&names[0])).expect("remove anchor entry");
assert!(matches!(ReadDir::open_at(path, &anchors[0]).await, Err(err) if err.kind() == io::ErrorKind::InvalidData));
});
}
#[test]
fn directory_prefetch_preserves_empty_and_exact_chunk_boundaries() {
runtime().block_on(async {
for count in [0, 1, DIRECTORY_CHUNK_SIZE, DIRECTORY_CHUNK_SIZE + 1] {
let root = directory(count);
let mut reader = ReadDir::open(root.path().to_str().expect("root path"), false)
.await
.expect("open");
let mut reader = ReadDir::open(root.path().to_str().expect("root path")).await.expect("open");
let mut names = std::collections::BTreeSet::new();
while let Some(entry) = reader.next_entry().await.expect("read entry") {
assert!(names.insert(entry.file_name()), "prefetch duplicated an entry");
@@ -494,9 +293,7 @@ mod tests {
fn failed_refill_is_an_error_after_partial_enumeration() {
runtime().block_on(async {
let root = directory(DIRECTORY_CHUNK_SIZE + 1);
let mut reader = ReadDir::open(root.path().to_str().expect("root path"), false)
.await
.expect("open");
let mut reader = ReadDir::open(root.path().to_str().expect("root path")).await.expect("open");
for _ in 0..DIRECTORY_CHUNK_SIZE {
assert!(reader.next_entry().await.expect("prefetched entry").is_some());
}
@@ -525,10 +322,10 @@ mod tests {
let root = directory(1);
let path = root.path().join("missing");
let missing = path.to_str().expect("missing path");
assert!(matches!(ReadDir::open(missing, false).await, Err(error) if error.kind() == io::ErrorKind::NotFound));
assert!(matches!(ReadDir::open(missing).await, Err(error) if error.kind() == io::ErrorKind::NotFound));
assert!(matches!(metadata(missing).await, Err(error) if error.kind() == io::ErrorKind::NotFound));
let file = root.path().join("object-0");
assert!(ReadDir::open(file.to_str().expect("file path"), false).await.is_err());
assert!(ReadDir::open(file.to_str().expect("file path")).await.is_err());
#[cfg(unix)]
{
let link = root.path().join("link");
@@ -1,209 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
//! Reopen an indexed directory at the last entry committed by the walker.
use std::ffi::OsStr;
use std::fs::{File, FileType, Metadata};
use std::io;
use std::os::unix::ffi::OsStrExt;
use std::os::unix::fs::MetadataExt;
use std::path::Path;
use std::sync::Arc;
use rustix::fs::{Dir, FileType as NativeType, Mode, OFlags, SeekFrom};
use sha2::{Digest, Sha256};
use super::{DirEntry, DirectoryAnchor, EntrySource, PositionedEntry};
// Darwin's dirent does not expose Linux d_off. Use the kernel buffer's start
// position and verify the consumed prefix of that buffer on a fresh handle.
#[cfg(target_os = "macos")]
const MAX_ANCHOR_PREFIX: u32 = 4096;
#[cfg(target_os = "linux")]
const MAX_ANCHOR_PREFIX: u32 = 1;
fn changed() -> io::Error {
io::Error::new(io::ErrorKind::InvalidData, "scanner directory position no longer matches its checkpoint")
}
fn resume_error(error: rustix::io::Errno) -> io::Error {
use rustix::io::Errno;
match error {
Errno::SPIPE | Errno::OPNOTSUPP => io::ErrorKind::Unsupported.into(),
Errno::INVAL | Errno::OVERFLOW | Errno::STALE => changed(),
other => other.into(),
}
}
fn hash_record(prefix: &mut Sha256, record: &rustix::fs::DirEntry) {
prefix.update(record.ino().to_le_bytes());
// Names cannot contain NUL. Include the terminator to delimit records.
prefix.update(record.file_name().to_bytes_with_nul());
}
fn identity(meta: &Metadata) -> [u8; 32] {
let mut digest = Sha256::new();
digest.update(std::env::consts::OS.as_bytes());
for value in [
meta.dev().to_le_bytes(),
meta.ino().to_le_bytes(),
meta.ctime().to_le_bytes(),
meta.ctime_nsec().to_le_bytes(),
meta.mtime().to_le_bytes(),
meta.mtime_nsec().to_le_bytes(),
] {
digest.update(value);
}
digest.finalize().into()
}
pub(super) struct Reader {
dir: Dir,
parent: Arc<Path>,
directory_type: FileType,
regular_type: Option<FileType>,
link_type: Option<FileType>,
identity: [u8; 32],
next_cookie: Option<u64>,
#[cfg(target_os = "macos")]
page: DarwinPage,
}
#[cfg(target_os = "macos")]
struct DarwinPage {
position: File,
start: Option<u64>,
count: u32,
prefix: Sha256,
}
impl Reader {
pub(super) fn open(path: &Path, resume: Option<&DirectoryAnchor>) -> io::Result<Self> {
let fd = File::from(rustix::fs::open(
path,
OFlags::RDONLY | OFlags::DIRECTORY | OFlags::CLOEXEC | OFlags::NOFOLLOW,
Mode::empty(),
)?);
let meta = fd.metadata()?;
let identity = identity(&meta);
let cookie = resume.map_or(0, |anchor| anchor.cookie);
if let Some(anchor) = resume {
if anchor.directory != identity || !(1..=MAX_ANCHOR_PREFIX).contains(&anchor.entries) {
return Err(changed());
}
if rustix::fs::seek(&fd, SeekFrom::Start(cookie)).map_err(resume_error)? != cookie {
return Err(changed());
}
}
#[cfg(target_os = "macos")]
let page = DarwinPage {
position: fd.try_clone()?,
start: Some(cookie),
count: 0,
prefix: Sha256::new(),
};
let mut reader = Self {
dir: Dir::new(fd)?,
parent: Arc::from(path),
directory_type: meta.file_type(),
regular_type: None,
link_type: None,
identity,
next_cookie: Some(cookie),
#[cfg(target_os = "macos")]
page,
};
if let Some(expected) = resume {
// A fresh libc stream can choose a different buffer size. Validate
// exactly the saved prefix, regardless of its new buffer boundaries.
let mut prefix = Sha256::new();
for _ in 0..expected.entries {
let record = reader.dir.read().transpose().map_err(resume_error)?.ok_or_else(changed)?;
hash_record(&mut prefix, &record);
reader.anchor(&record);
}
if prefix.finalize()[..] != expected.prefix {
return Err(changed());
}
}
Ok(reader)
}
fn anchor(&mut self, record: &rustix::fs::DirEntry) -> Option<DirectoryAnchor> {
#[cfg(target_os = "linux")]
let mut single = Sha256::new();
#[cfg(target_os = "linux")]
let (cookie, entries, prefix) = {
let cookie = self.next_cookie;
self.next_cookie = u64::try_from(record.offset()).ok();
(cookie?, 1, &mut single)
};
#[cfg(target_os = "macos")]
let (cookie, entries, prefix) = {
let after = rustix::fs::tell(&self.page.position).ok();
if after != self.next_cookie {
self.page.start = self.next_cookie;
self.next_cookie = after;
self.page.count = 0;
self.page.prefix = Sha256::new();
}
self.page.count = self.page.count.saturating_add(1);
if self.page.count > MAX_ANCHOR_PREFIX {
return None;
}
(self.page.start?, self.page.count, &mut self.page.prefix)
};
hash_record(prefix, record);
Some(DirectoryAnchor {
directory: self.identity,
cookie,
entries,
prefix: prefix.clone().finalize().into(),
})
}
fn file_type(&mut self, kind: NativeType, name: &OsStr) -> Option<FileType> {
// std::fs::FileType has no public constructor. Reuse the observed type
// only when the kernel dirent identified the same class. DT_UNKNOWN
// and special files retain the per-entry symlink_metadata fallback.
let cached = match kind {
NativeType::Directory => return Some(self.directory_type),
NativeType::RegularFile => &mut self.regular_type,
NativeType::Symlink => &mut self.link_type,
_ => return None,
};
if cached.is_none() {
let ty = std::fs::symlink_metadata(self.parent.join(name)).ok()?.file_type();
if (ty.is_file() && kind == NativeType::RegularFile) || (ty.is_symlink() && kind == NativeType::Symlink) {
*cached = Some(ty);
}
return Some(ty);
}
*cached
}
pub(super) fn next(&mut self) -> Option<io::Result<DirEntry>> {
loop {
let raw = match self.dir.read()? {
Ok(record) => record,
Err(error) => return Some(Err(error.into())),
};
let anchor = self.anchor(&raw);
let bytes = raw.file_name().to_bytes();
if matches!(bytes, b"." | b"..") {
continue;
}
let name = OsStr::from_bytes(bytes);
let file_type = self.file_type(raw.file_type(), name);
return Some(Ok(DirEntry {
source: EntrySource::Positioned(Arc::new(PositionedEntry {
parent: self.parent.clone(),
name: name.into(),
anchor,
})),
file_type,
}));
}
}
}
+1 -8
View File
@@ -30,7 +30,7 @@ use std::sync::Mutex;
pub(super) mod checkpoint_fixture;
pub(super) mod enumeration_restart;
pub(super) mod fair_prefix_quantum;
mod fair_prefix_quantum;
mod incremental_enumeration;
mod listing_completion;
mod metadata_visits;
@@ -403,7 +403,6 @@ async fn build_test_scanner() -> (FolderScanner, std::path::PathBuf) {
resume_failed_paths: Vec::new(),
coverage_gap: false,
raw_enumeration_progress: Vec::new(),
directory_checkpoints: HashMap::new(),
pending_size_reconciliation_keys: HashSet::new(),
pending_size_reconciliation_scopes: HashSet::new(),
pending_size_reconciliation_truncated: false,
@@ -3145,12 +3144,6 @@ async fn scoped_root_scan_reuses_clean_top_level_entries_and_rescans_dirty_entri
parent: None,
object_heal_prob_div: 1,
};
// The sorted queue can reach a budget stop after linking a clean prefix
// but before the first dirty child advances the durable sweep frontier.
assert!(!scanner.can_reuse_covered_namespace("bucket/clean", false));
assert!(scanner.can_restore_linked_child(&folder, &DataUsageEntry::default(), "bucket/clean"));
assert!(!scanner.can_restore_linked_child(&folder, &DataUsageEntry::default(), "bucket/dirty"));
assert!(!scanner.can_restore_linked_child(&folder, &DataUsageEntry::default(), "bucket/absent"));
let mut root = DataUsageEntry::default();
scanner
.scan_folder(CancellationToken::new(), folder, &mut root)
@@ -1130,7 +1130,7 @@ async fn checkpoint_admission_log_capture_survives_another_future_dispatcher() {
}
}
pub(super) async fn write_checkpoint_object(root: &std::path::Path, object: &str, versions: &[(Option<Uuid>, i64)]) {
async fn write_checkpoint_object(root: &std::path::Path, object: &str, versions: &[(Option<Uuid>, i64)]) {
let mut metadata = FileMeta::new();
for (index, (version_id, size)) in versions.iter().enumerate() {
let mut info = FileInfo::new(object, 4, 2);
@@ -820,11 +820,6 @@ async fn periodic_nested_snapshot_adoption_records_checkpoint_used_on_real_scan_
.await
.expect("create the real cached subtree directory");
let (mut cache, _) = bound_checkpoint();
cache.info.scan_directory_source = Some(
directory_cursor::physical_source(&scanner.local_disk)
.await
.expect("fixture disk source"),
);
cache.info.skip_healing = true;
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(
@@ -861,80 +856,6 @@ async fn periodic_nested_snapshot_adoption_records_checkpoint_used_on_real_scan_
assert_eq!(budget.reason(), None);
}
#[tokio::test]
#[serial]
async fn periodic_compacted_checkpoint_survives_a_crash_inside_the_first_quantum() {
use super::super::{enumeration_restart::seed_flat_bucket, fair_prefix_quantum::run_until_finished};
let (mut scanner, root) = build_test_scanner().await;
let _guard = TestGuard {
temp_dir: Some(root.clone()),
};
// seed_flat_bucket creates its directory; retain the allocated native
// disk and initialize this already-created bucket in the same shape.
let template = tempfile::tempdir().expect("fixture directory");
let cache = seed_flat_bucket(&template.path().join("initial"), 0).await;
for index in 0..40 {
write_checkpoint_object(&root, &format!("object-{index:04}"), &[(Some(Uuid::from_u128(index + 1)), 3)]).await;
}
prepare_scanner(&mut scanner, cache);
let (tx, mut rx) = mpsc::channel(1);
scanner.checkpoint_tx = Some(tx);
scanner.checkpoint_objects = SCANNER_CHECKPOINT_OBJECT_INTERVAL - 1;
scanner.last_checkpoint_at = Instant::now()
.checked_sub(SCANNER_CHECKPOINT_MIN_INTERVAL)
.expect("checkpoint interval");
let ctx = CancellationToken::new();
scanner.budget = ScannerCycleBudget::new_with_progress_tracking(&ctx, Default::default());
let mut entry = DataUsageEntry::default();
super::super::super::TEST_FORCE_COMPACTION_WIDTH
.scope(16, async {
let checkpoint = {
let scan = scanner.scan_folder(
ctx.clone(),
CachedFolder {
name: "bucket".to_owned(),
parent: None,
object_heal_prob_div: 1,
},
&mut entry,
);
tokio::pin!(scan);
tokio::select! {
checkpoint=rx.recv()=>checkpoint.expect("compacted owner emitted a periodic checkpoint"),
result=&mut scan=>panic!("scan returned before it checkpointed a completed compacted child: {result:?}"),
}
};
assert!(!ctx.is_cancelled());
assert!(!checkpoint.info.snapshot_complete);
assert!(
checkpoint
.info
.scan_directory_work
.iter()
.any(|receipt| receipt.progress(&checkpoint.info).is_some())
);
let total = checkpoint.checked_flatten("bucket").expect("connected partial root");
assert!((1..40).contains(&total.objects));
assert_eq!(total.size, total.objects * 3);
let bytes = checkpoint.marshal_msg().expect("persist running checkpoint");
drop(scanner);
let durable = DataUsageCache::unmarshal(&bytes).expect("reload checkpoint after crash");
let resumed = run_until_finished(
&root,
durable,
ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
},
12,
)
.await;
let complete = resumed.checked_flatten("bucket").expect("restarted compacted root");
assert_eq!((complete.objects, complete.size, complete.versions), (40, 120, 40));
})
.await;
}
#[tokio::test]
#[serial]
async fn periodic_nested_snapshot_does_not_publish_shared_compacted_accumulator_under_child_path() {
@@ -15,7 +15,6 @@ struct Observation {
name_bytes: u64,
first_entry: Option<String>,
last_entry: Option<String>,
cancel_owner: Option<CancellationToken>,
}
static OBSERVATION: Mutex<Option<Observation>> = Mutex::new(None);
@@ -39,11 +38,7 @@ pub(in crate::scanner_folder) fn observe_raw_entry(dir: &str, name: &std::ffi::O
observation.entries += 1;
observation.name_bytes += u64::try_from(name.as_encoded_bytes().len()).expect("bounded entry name");
if observation.entries >= observation.limit {
if let Some(owner) = &observation.cancel_owner {
owner.cancel();
} else {
budget.cancel_for_runtime();
}
budget.cancel_for_runtime();
}
}
}
@@ -68,26 +63,10 @@ pub(in crate::scanner_folder) fn install_raw_entry_budget(root: PathBuf, limit:
name_bytes: 0,
first_entry: None,
last_entry: None,
cancel_owner: None,
});
ObservationGuard
}
pub(in crate::scanner_folder) fn install_raw_entry_owner_cancel(
root: PathBuf,
limit: u64,
owner: CancellationToken,
) -> ObservationGuard {
let guard = install_raw_entry_budget(root, limit);
OBSERVATION
.lock()
.expect("install owner cancellation")
.as_mut()
.expect("installed observation")
.cancel_owner = Some(owner);
guard
}
#[derive(serde::Deserialize)]
#[serde(deny_unknown_fields)]
struct Request {
@@ -74,9 +74,7 @@ pub(in crate::scanner_folder) async fn ordered_entries(
}
let mut entries = Vec::new();
while let Some(entry) = reader.next_entry().await? {
// This fixture reorders native entries. Their kernel positions no
// longer describe the prefixes delivered to the walker.
entries.push(entry.without_anchor());
entries.push(entry);
}
// Real entries and file types, with an explicit adversarial order rather
// than an assumption about the filesystem's enumeration order.
@@ -535,32 +533,6 @@ async fn erasure_candidate_defers_metadata_until_part_classification_finishes()
#[tokio::test]
#[serial]
async fn erasure_candidate_cancelled_batch_keeps_partial_checkpoint_and_reclassifies_on_resume() {
check_candidate_resume(CandidateResume::Legacy, 136).await;
}
#[tokio::test]
#[serial]
async fn erasure_candidate_warm_resume_avoids_rereading_sealed_root() {
check_candidate_resume(CandidateResume::Warm, 135).await;
}
#[cfg(any(unix, windows))]
#[tokio::test]
#[serial]
async fn erasure_candidate_cold_resume_uses_the_validated_sealed_root() {
check_candidate_resume(CandidateResume::Cold, 135).await;
}
enum CandidateResume {
Warm,
Legacy,
#[cfg(any(unix, windows))]
Cold,
}
async fn check_candidate_resume(kind: CandidateResume, expected_io: u64) {
use crate::storage_api::owner::EcstoreDiskAPI;
let (mut scanner, root, folder) = candidate_scanner().await;
let _guard = TestGuard {
temp_dir: Some(root.clone()),
@@ -624,33 +596,7 @@ async fn check_candidate_resume(kind: CandidateResume, expected_io: u64) {
.expect("validated candidate index");
assert_eq!(index.indexed_entries().expect("index entries").len(), 64);
let bytes = serde_json::to_vec(&snapshot).expect("serialize partial checkpoint");
let mut reloaded: DataUsageCache = serde_json::from_slice(&bytes).expect("reload partial checkpoint");
if !matches!(kind, CandidateResume::Warm) {
scanner.directory_checkpoints.clear();
if matches!(kind, CandidateResume::Legacy) {
// A pre-directory-checkpoint writer persisted raw names but no
// authenticated physical position or sealed membership manifest.
reloaded.info.scan_directory_source = None;
reloaded.info.scan_directory_work.clear();
} else {
for state in &reloaded.info.scan_directory_work {
scanner
.directory_checkpoints
.entry(state.parent().to_owned())
.or_default()
.insert(state.endpoint().to_owned(), Arc::new(std::sync::Mutex::new(Some(state.clone()))));
}
}
scanner.local_disk = new_disk(
&scanner.local_disk.endpoint(),
&DiskOption {
cleanup: false,
health_check: false,
},
)
.await
.expect("reopen cold scanner disk");
}
let reloaded: DataUsageCache = serde_json::from_slice(&bytes).expect("reload partial checkpoint");
scanner.old_cache = reloaded.clone();
scanner.new_cache = reloaded;
scanner.raw_enumeration_progress.clear();
@@ -669,8 +615,8 @@ async fn check_candidate_resume(kind: CandidateResume, expected_io: u64) {
);
assert_eq!(
charged_ops(&root),
expected_io,
"resume charges every physical read, including cold reconstruction of the root"
136,
"resume recharges actual reads; the raw index is not a filesystem seek"
);
}
@@ -4,25 +4,6 @@
use super::enumeration_restart::{install_raw_entry_observer, observed_raw_entries, seed_flat_bucket};
use super::*;
use crate::scanner_budget::ScannerCycleBudgetConfig;
use std::cell::Cell;
use std::path::PathBuf;
const PHYSICAL_READ_COST: Duration = Duration::from_secs(60);
tokio::task_local! {
static SLOW_DIRECTORY: (PathBuf, Cell<usize>);
}
pub(in crate::scanner_folder) fn is_slow_directory(path: &str) -> bool {
SLOW_DIRECTORY.try_with(|(directory, _)| directory.as_path() == std::path::Path::new(path)) == Ok(true)
}
/// Charge every read attempt (including replay and EOF) before entries leave
/// the native buffer, so cancelling a simulated slow read cannot skip a name.
pub(in crate::scanner_folder) async fn charge_physical_read() {
SLOW_DIRECTORY.with(|(_, reads)| reads.set(reads.get() + 1));
tokio::time::advance(PHYSICAL_READ_COST).await;
}
async fn open_fixture_disk(disk_root: &std::path::Path) -> Arc<Disk> {
let endpoint = Endpoint::try_from(disk_root.to_string_lossy().as_ref()).expect("fixture endpoint");
@@ -37,73 +18,6 @@ async fn open_fixture_disk(disk_root: &std::path::Path) -> Arc<Disk> {
.expect("open synthetic disk")
}
#[tokio::test(start_paused = true)]
#[serial]
async fn wide_directory_runtime_budget_reaches_eof() {
const WIDTH: usize = 48;
const ROUNDS: usize = 16;
let temp = tempfile::tempdir().expect("fixture directory");
let disk_root = temp.path().join("disk");
let mut cache = seed_flat_bucket(&disk_root, WIDTH).await;
let disk = open_fixture_disk(&disk_root).await;
let mut anchor = FileInfo::new("large", 4, 2);
anchor.volume = "bucket".to_owned();
anchor.version_id = Some(Uuid::from_u128(1000));
anchor.versioned = true;
anchor.mod_time = Some(OffsetDateTime::now_utc());
anchor.size = 4096;
let mut metadata = FileMeta::new();
metadata.add_version(anchor).expect("large fixture object");
write_test_object_metadata_bytes(&disk_root, "bucket", "large", &metadata.marshal_msg().expect("encode large object")).await;
let parent = CancellationToken::new();
let expected = (WIDTH + 1, WIDTH + 4096);
let scan = async {
for prior_timeouts in 0..ROUNDS {
let budget = ScannerCycleBudget::new_with_progress_tracking(
&parent,
ScannerCycleBudgetConfig {
max_duration: Some(8 * PHYSICAL_READ_COST),
..Default::default()
},
);
let result = scan_data_folder(
budget.token(),
budget.clone(),
vec![disk.clone()],
disk.clone(),
cache.clone(),
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await;
match result {
Ok(complete) => {
assert!(prior_timeouts >= 2, "the wide directory must span multiple actual runtime deadlines");
assert!(complete.info.snapshot_complete);
let totals = complete.checked_flatten("bucket").expect("complete bucket root");
assert_eq!((totals.objects, totals.size), expected);
return;
}
Err(ScannerError::PartialCache(partial)) => {
assert!(!partial.info.snapshot_complete);
cache = DataUsageCache::unmarshal(&partial.marshal_msg().expect("persist partial")).expect("reload partial");
}
Err(ScannerError::Other(message)) if budget.token().is_cancelled() && message == "Operation cancelled" => {}
Err(error) => panic!("unexpected scan failure: {error}"),
}
assert_eq!(budget.reason(), Some(crate::scanner_budget::ScannerCycleBudgetReason::Runtime));
}
let reads = SLOW_DIRECTORY.with(|(_, count)| count.get());
let totals = cache.checked_flatten("bucket").expect("last partial root");
panic!(
"wide directory still incomplete after {ROUNDS} fixed runtime deadlines and {reads} physical reads: {} objects, {} bytes",
totals.objects, totals.size
);
};
SLOW_DIRECTORY.scope((disk.path().join("bucket"), Cell::new(0)), scan).await;
}
/// A count budget is the operator's total work limit. It must also stop the
/// first listing of a directory far wider than that budget, instead of letting
/// one read_dir pass finish before the first object is charged.
@@ -161,28 +75,15 @@ async fn scan_one_restart_round(
disk_root: &std::path::Path,
cache: DataUsageCache,
config: ScannerCycleBudgetConfig,
) -> RestartRound {
scan_one_replica_round(disk_root, None, cache, config).await
}
async fn scan_one_replica_round(
disk_root: &std::path::Path,
peer: Option<&std::path::Path>,
cache: DataUsageCache,
config: ScannerCycleBudgetConfig,
) -> RestartRound {
let disk = open_fixture_disk(disk_root).await;
let mut disks = vec![disk.clone()];
if let Some(peer) = peer {
disks.push(open_fixture_disk(peer).await);
}
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(&parent, config);
let _observation = install_raw_entry_observer(disk.path());
let result = scan_data_folder(
budget.token(),
budget.clone(),
disks,
vec![disk.clone()],
disk,
cache.clone(),
None,
@@ -204,7 +105,7 @@ async fn scan_one_replica_round(
}
}
pub(super) async fn run_until_finished(
async fn run_until_finished(
disk_root: &std::path::Path,
mut cache: DataUsageCache,
config: ScannerCycleBudgetConfig,
@@ -330,684 +231,3 @@ async fn fair_prefix_quantum_budget_stop_keeps_progress_without_certifying_it()
let expected = u64::try_from(OBJECTS).expect("fixture size");
assert_eq!((totals.objects as u64, totals.versions as u64), (expected, expected));
}
#[tokio::test]
#[serial]
async fn cold_compacted_directory_totals_progress_after_every_executor_restart() {
let temp = tempfile::tempdir().expect("fixture directory");
let root = temp.path().join("disk");
let mut cache = seed_flat_bucket(&root, 40).await;
let budget = ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
};
super::super::TEST_FORCE_COMPACTION_WIDTH
.scope(16, async {
let mut partial_counts = Vec::new();
for round in 0..16 {
let step = scan_one_restart_round(&root, cache.clone(), budget).await;
if !step.finished {
assert!(
step.outcome
.durable_scan_progress()
.advanced_from(&cache.durable_scan_progress()),
"each cold compacted round must earn a coordinator service turn, round {round}"
);
}
cache = step.outcome;
let total = cache.checked_flatten("bucket").expect("connected compact bucket");
if step.finished {
assert!(round > 1);
assert!(cache.info.snapshot_complete);
assert_eq!((total.objects, total.size, total.versions), (40, 40, 40));
return;
}
assert!(!cache.info.snapshot_complete);
partial_counts.push(total.objects);
}
panic!("cold compacted scan did not finish in 16 rounds; objects per partial: {partial_counts:?}");
})
.await;
}
#[tokio::test]
#[serial]
async fn cold_compacted_replicas_finish_within_their_independent_object_budgets() {
let temp = tempfile::tempdir().expect("fixture directory");
let first = temp.path().join("a");
let other = temp.path().join("b");
let mut cache = seed_flat_bucket(&first, 40).await;
tokio::fs::create_dir_all(&other).await.expect("fresh replica");
for index in (0..40).rev() {
let name = format!("object-{index:04}");
let metadata = tokio::fs::read(first.join("bucket").join(&name).join("xl.meta"))
.await
.expect("original metadata");
write_test_object_metadata_bytes(&other, "bucket", &name, &metadata).await;
}
let budget = ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
};
super::super::TEST_FORCE_COMPACTION_WIDTH
.scope(16, async {
for round in 0..(2 * 40_usize.div_ceil(6) + 1) {
let root = if round % 2 == 0 { &first } else { &other };
let peer = if round % 2 == 0 { &other } else { &first };
let step = scan_one_replica_round(root, Some(peer), cache.clone(), budget).await;
if !step.finished {
assert!(
step.outcome
.durable_scan_progress()
.advanced_from(&cache.durable_scan_progress()),
"cross-disk compacted work should advance durable scheduling, round {round}"
);
}
cache = step.outcome;
if step.finished {
assert!(round > 1);
assert!(cache.info.snapshot_complete);
let total = cache.checked_flatten("bucket").expect("complete switched source");
assert_eq!((total.objects, total.size), (40, 40));
return;
}
}
panic!("two cold physical replicas did not converge within two independent object work budgets");
})
.await;
}
#[tokio::test]
#[serial]
async fn cold_compacted_identical_names_do_not_mix_replica_version_sizes() {
use super::checkpoint_fixture::write_checkpoint_object;
let temp = tempfile::tempdir().expect("fixture directory");
let a = temp.path().join("a");
let b = temp.path().join("b");
let start = seed_flat_bucket(&a, 40).await;
seed_flat_bucket(&b, 40).await;
write_checkpoint_object(&b, "object-0000", &[(Some(Uuid::from_u128(100)), 11), (Some(Uuid::from_u128(101)), 23)]).await;
let config = ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
};
super::super::TEST_FORCE_COMPACTION_WIDTH
.scope(16, async {
let first = scan_one_replica_round(&a, Some(&b), start, config).await;
assert!(!first.finished);
let mut cache = first.outcome;
for _ in 0..10 {
let round = scan_one_replica_round(&b, Some(&a), cache, config).await;
cache = round.outcome;
if round.finished {
break;
}
}
let complete = cache;
assert!(complete.info.snapshot_complete);
let counted = complete.checked_flatten("bucket").expect("complete B accounting");
// 39 one-byte objects and both retained versions of the remaining key.
assert_eq!((counted.objects, counted.size, counted.versions), (40, 73, 41));
})
.await;
}
#[tokio::test]
#[serial]
async fn legacy_unbound_partial_restarts_on_the_actual_physical_replica() {
use super::checkpoint_fixture::write_checkpoint_object;
let temp = tempfile::tempdir().expect("fixture");
let a = temp.path().join("a");
let b = temp.path().join("b");
let cache = seed_flat_bucket(&a, 40).await;
seed_flat_bucket(&b, 40).await;
write_checkpoint_object(&b, "object-0000", &[(Some(Uuid::from_u128(200)), 12), (Some(Uuid::from_u128(201)), 31)]).await;
let config = ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
};
let first = scan_one_restart_round(&a, cache, config).await;
let mut legacy = first.outcome;
assert!(legacy.validated_scan_frontier().is_some());
legacy.info.scan_directory_source = None;
legacy.info.scan_directory_work.clear();
legacy.info.scan_source_trees.clear();
let upgraded = run_until_finished(&b, legacy, config, 10).await;
let total = upgraded.checked_flatten("bucket").expect("B complete");
assert_eq!((total.objects, total.size, total.versions), (40, 82, 41));
}
#[tokio::test]
#[serial]
async fn cold_linked_prefixes_resume_their_own_replica_coverage() {
use super::checkpoint_fixture::write_checkpoint_object;
let temp = tempfile::tempdir().expect("fixture directory");
let a = temp.path().join("a");
let b = temp.path().join("b");
let mut cache = seed_flat_bucket(&a, 40).await;
seed_flat_bucket(&b, 40).await;
write_checkpoint_object(&b, "object-0000", &[(Some(Uuid::from_u128(100)), 11), (Some(Uuid::from_u128(101)), 23)]).await;
let config = ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
};
// Six turns per disk leave one final B quantum. Each cold process must
// recover that disk's linked tree as well as its complete child coverage.
for round in 0..(2 * 40_usize.div_ceil(6) + 1) {
let (root, peer) = if round < 12 && round % 2 == 0 { (&a, &b) } else { (&b, &a) };
let previous_source = cache.info.scan_directory_source.clone();
let before = cache.durable_scan_progress();
let result = scan_one_replica_round(root, Some(peer), cache, config).await;
if !result.finished {
assert!(
result.outcome.durable_scan_progress().advanced_from(&before),
"linked source must earn another turn, round {round}"
);
}
cache = result.outcome;
if round == 1 {
let previous_source = previous_source.expect("A's physical source");
let endpoints = [
previous_source.as_str(),
cache.info.scan_directory_source.as_deref().expect("B's physical source"),
]
.map(|source| source.split_once('|').expect("disk generation and endpoint").1.to_owned())
.into_iter()
.collect();
let mut only_switched = cache.clone();
only_switched.activate_directory_source(previous_source, &endpoints);
assert!(only_switched.validated_scan_frontier().is_some(), "A's linked coverage is retained");
assert!(
!only_switched
.durable_scan_progress()
.advanced_from(&cache.durable_scan_progress()),
"moving a linked source between active and dormant earns no new turn"
);
}
if result.finished {
assert_eq!(root, &b);
assert!(cache.info.snapshot_complete);
let root = cache.find("bucket").expect("complete linked bucket");
assert!(!root.compacted);
assert_eq!(root.children.len(), 40);
let counted = cache.checked_flatten("bucket").expect("full B view");
assert_eq!((counted.objects, counted.size, counted.versions), (40, 73, 41));
return;
}
}
panic!("two independent cold linked prefix scans did not converge");
}
#[tokio::test]
#[serial]
async fn cold_compacted_changed_replica_does_not_import_another_disks_totals() {
let temp = tempfile::tempdir().expect("fixture directory");
let first = temp.path().join("a");
let other = temp.path().join("b");
let baseline = seed_flat_bucket(&first, 40).await;
seed_flat_bucket(&other, 40).await;
// Object zero was already counted on A but never existed in B's view.
// Importing A's subtotal based only on a matching child boundary would
// produce 40 objects on B even though its authoritative listing has 39.
tokio::fs::remove_dir_all(other.join("bucket/object-0000"))
.await
.expect("different replica membership");
let config = ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
};
super::super::TEST_FORCE_COMPACTION_WIDTH
.scope(16, async {
let first = scan_one_restart_round(&first, baseline, config).await;
assert!(!first.finished);
let complete = run_until_finished(&other, first.outcome, config, 14).await;
let root = complete.checked_flatten("bucket").expect("finished replica");
assert_eq!((root.objects, root.versions, root.size), (39, 39, 39));
})
.await;
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
#[tokio::test(start_paused = true)]
#[serial]
async fn cold_wide_listing_rotates_physical_endpoints_before_eof() {
let temp = tempfile::tempdir().expect("fixture directory");
let first = temp.path().join("a");
let other = temp.path().join("b");
let mut cache = seed_flat_bucket(&first, 49).await;
seed_flat_bucket(&other, 49).await;
let config = ScannerCycleBudgetConfig {
max_duration: Some(8 * PHYSICAL_READ_COST),
..Default::default()
};
for round in 0..22 {
let disk = if round % 2 == 0 { &first } else { &other };
let peer = if round % 2 == 0 { &other } else { &first };
let physical = disk.join("bucket").canonicalize().expect("physical directory");
let before = cache.durable_scan_progress();
let step = SLOW_DIRECTORY
.scope((physical, Cell::new(0)), scan_one_replica_round(disk, Some(peer), cache, config))
.await;
if !step.finished {
assert!(
step.outcome.durable_scan_progress().advanced_from(&before),
"each independent native resume must advance durable scheduling, round {round}"
);
}
cache = step.outcome;
if step.finished {
assert!(round > 2);
assert!(cache.info.snapshot_complete);
let total = cache.checked_flatten("bucket").expect("switched cold listing");
assert_eq!((total.objects, total.size), (49, 49));
return;
}
}
panic!("rotating before EOF repeatedly overwrote an endpoint's physical progress");
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
#[tokio::test(start_paused = true)]
#[serial]
async fn cold_wide_listing_reaches_eof_after_every_executor_restart() {
let temp = tempfile::tempdir().expect("fixture directory");
let root = temp.path().join("disk");
let mut cache = seed_flat_bucket(&root, 49).await;
let budget = ScannerCycleBudgetConfig {
max_duration: Some(8 * PHYSICAL_READ_COST),
..Default::default()
};
SLOW_DIRECTORY
.scope((root.join("bucket").canonicalize().expect("physical path"), Cell::new(0)), async {
for round in 0..16 {
let step = scan_one_restart_round(&root, cache.clone(), budget).await;
cache = step.outcome;
if step.finished {
assert!(round > 1);
assert!(cache.info.snapshot_complete);
let total = cache.checked_flatten("bucket").expect("complete bucket");
assert_eq!((total.objects, total.size), (49, 49));
return;
}
assert!(!cache.info.snapshot_complete);
}
let reads = SLOW_DIRECTORY.with(|(_, reads)| reads.get());
panic!("cold physical listing did not reach EOF after 16 rounds and {reads} directory reads");
})
.await;
}
#[tokio::test]
#[serial]
async fn wide_compacted_directory_reuses_only_finished_children() {
const WIDTH: usize = 40;
let temp = tempfile::tempdir().expect("fixture directory");
let disk_root = temp.path().join("disk");
let mut cache = seed_flat_bucket(&disk_root, WIDTH).await;
let disk = open_fixture_disk(&disk_root).await;
let parent = CancellationToken::new();
super::super::TEST_FORCE_COMPACTION_WIDTH
.scope(16, async {
for round in 0..16 {
let budget = ScannerCycleBudget::new_with_progress_tracking(
&parent,
ScannerCycleBudgetConfig {
max_objects: Some(6),
..Default::default()
},
);
let result = scan_data_folder(
budget.token(),
budget,
vec![disk.clone()],
disk.clone(),
cache.clone(),
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await;
match result {
Ok(completed) => {
assert!(round > 1);
assert!(completed.info.snapshot_complete);
let root = completed.find("bucket").expect("compacted bucket");
assert!(root.compacted);
assert_eq!((root.objects, root.size), (WIDTH, WIDTH));
return;
}
Err(ScannerError::PartialCache(partial)) => {
cache = DataUsageCache::unmarshal(&partial.marshal_msg().expect("save compacted checkpoint"))
.expect("reload partial");
}
Err(error) => panic!("unexpected compacted scan failure: {error}"),
}
}
panic!("fixed object budget failed to finish compacted children");
})
.await;
}
#[tokio::test]
#[serial]
async fn wide_directory_replacement_invalidates_parked_entries() {
const WIDTH: usize = 48;
let temp = tempfile::tempdir().expect("fixture directory");
let disk_root = temp.path().join("disk");
let initial = seed_flat_bucket(&disk_root, WIDTH).await;
let disk = open_fixture_disk(&disk_root).await;
let parent = CancellationToken::new();
let config = ScannerCycleBudgetConfig {
max_entries: Some(3),
..Default::default()
};
let budget = ScannerCycleBudget::new_with_progress_tracking(&parent, config);
let Err(ScannerError::PartialCache(partial)) = scan_data_folder(
budget.token(),
budget,
vec![disk.clone()],
disk.clone(),
initial,
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await
else {
panic!("the original listing must stop before EOF")
};
assert!(
super::super::parked_bucket_disks("bucket")
.iter()
.any(|scope| scope.ptr_eq(&Arc::downgrade(&disk)))
);
let mut cache = *partial;
// Rename pins the old inode. Reusing its open stream or its name pages
// would visit the vanished objects and omit this replacement's metadata.
tokio::fs::rename(disk_root.join("bucket"), temp.path().join("previous"))
.await
.expect("move old namespace");
let metadata = metadata_for_object_version("bucket", "successor", Some(Uuid::from_u128(100)));
write_test_object_metadata_bytes(&disk_root, "bucket", "successor", &metadata).await;
for _ in 0..6 {
let budget = ScannerCycleBudget::new_with_progress_tracking(&parent, config);
match scan_data_folder(
budget.token(),
budget,
vec![disk.clone()],
disk.clone(),
cache.clone(),
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await
{
Ok(complete) => {
assert!(complete.info.snapshot_complete);
let total = complete.checked_flatten("bucket").expect("current root");
assert_eq!((total.objects, total.size), (1, 1));
assert!(complete.find("bucket/successor").is_some());
assert!(
!super::super::parked_bucket_disks("bucket")
.iter()
.any(|scope| scope.ptr_eq(&Arc::downgrade(&disk)))
);
return;
}
Err(ScannerError::PartialCache(partial)) => cache = *partial,
Err(error) => panic!("replacement scan failed: {error}"),
}
}
panic!("replacement directory never finished");
}
#[tokio::test]
#[serial]
async fn wide_directory_deleted_bucket_releases_a_slot_under_pressure() {
use super::super::directory_cursor::{DirectoryScope, PARKED_DIRECTORIES_PER_DISK, ScannerDirectory, is_parked};
let temp = tempfile::tempdir().expect("fixture directory");
let disk_root = temp.path().join("disk");
let cache = seed_flat_bucket(&disk_root, 0).await;
let disk = open_fixture_disk(&disk_root).await;
let scope = DirectoryScope::new(&disk, &cache, FolderScanMode::Namespace, None).expect("physical source and owner");
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(&parent, ScannerCycleBudgetConfig::default());
budget.cancel_for_runtime();
let retired = disk_root.join("retired");
for index in 0..PARKED_DIRECTORIES_PER_DISK {
let path = retired.join(index.to_string());
tokio::fs::create_dir_all(&path).await.expect("create parked directory");
let path = path.to_str().expect("fixture path");
let directory = ScannerDirectory::open(path, "bucket", Some(scope.clone()), budget.clone(), None)
.await
.expect("open source");
drop(directory);
assert!(is_parked(path));
}
let next = disk_root.join("replacement");
tokio::fs::create_dir(&next).await.expect("current source");
let next = next.to_str().expect("fixture path");
let directory = ScannerDirectory::open(next, "bucket", Some(scope.clone()), budget.clone(), None)
.await
.expect("open next source");
drop(directory);
assert!(!is_parked(next), "active owners retain their bounded slots");
tokio::fs::remove_dir_all(retired).await.expect("retire directories");
let directory = ScannerDirectory::open(next, "bucket", Some(scope), budget, None)
.await
.expect("admit after retirement");
drop(directory);
assert!(is_parked(next), "an obsolete source must not indefinitely exclude new work");
super::super::directory_cursor::forget_bucket(&disk, &cache.info);
}
#[tokio::test]
#[serial]
async fn raw_directory_replay_reports_discovery_without_recharging_known_entries() {
let temp = tempfile::tempdir().expect("fixture directory");
let disk_root = temp.path().join("disk");
let mut cache = seed_flat_bucket(&disk_root, 0).await;
let mut index =
RawEnumerationPageWriter::new(RawEnumerationPageIndex::new("bucket", 16).expect("raw index")).expect("raw index writer");
for n in 0..64 {
tokio::fs::create_dir_all(disk_root.join("bucket").join(format!("object-{n:04}")))
.await
.expect("existing directory member");
index.record_entry(&format!("object-{n:04}")).expect("known directory member");
}
cache.info.scan_raw_enumeration_page_index = Some(index.checkpoint().expect("persist logical enumeration"));
assert_eq!(
cache
.validated_raw_enumeration_page_index()
.expect("valid logical checkpoint")
.committed_entries()
.expect("known entries")
.len(),
64
);
let disk = open_fixture_disk(&disk_root).await;
cache.info.scan_directory_source = Some(
super::super::directory_cursor::physical_source(&disk)
.await
.expect("bind the retained logical index to its physical source"),
);
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(
&parent,
ScannerCycleBudgetConfig {
max_entries: Some(1),
..Default::default()
},
);
let complete = scan_data_folder(
budget.token(),
budget.clone(),
vec![disk.clone()],
disk.clone(),
cache,
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await
.expect("known entries do not exhaust the one-entry budget");
assert_eq!(budget.reason(), None);
assert_eq!(complete.checked_flatten("bucket").expect("bucket root").objects, 0);
assert_eq!(
budget.entries_visited(),
64,
"real directory discovery must keep the remote stream alive while replaying known names"
);
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
#[tokio::test]
#[serial]
async fn ordinary_owner_cancellation_persists_directory_position_for_cold_resume() {
use super::super::directory_cursor::is_parked;
use super::enumeration_restart::install_raw_entry_owner_cancel;
let temp = tempfile::tempdir().expect("fixture directory");
let disk_root = temp.path().join("disk");
let mut cache = seed_flat_bucket(&disk_root, 64).await;
let tier = runtime_tier_registry_for_cycle(cache.info.next_cycle, cache.info.leader_epoch).await;
cache
.info
.scan_identity
.as_mut()
.expect("scan identity")
.tier_registry_generation = tier.generation;
cache.info.tier_registry_generation = Some(tier.generation);
let disk = open_fixture_disk(&disk_root).await;
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(&parent, ScannerCycleBudgetConfig::default());
let observer = install_raw_entry_owner_cancel(disk.path(), 16, parent.clone());
let result = scan_data_folder(
budget.token(),
budget.clone(),
vec![disk.clone()],
disk.clone(),
cache,
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await;
drop(observer);
assert!(parent.is_cancelled());
assert_eq!(budget.reason(), None, "the owner stopped independently of the cycle budget");
let Err(ScannerError::PartialCache(partial)) = result else {
panic!("ordinary cancellation must retain a partial cache");
};
assert_eq!(partial.info.scan_directory_work.len(), 1, "retain the physical directory receipt");
let saved = serde_json::to_value(&partial.info.scan_directory_work[0]).expect("directory receipt");
assert_eq!(saved["entries_read"], 16);
assert!(!is_parked(disk.path().join("bucket").to_str().expect("fixture path")));
let path = temp.path().join("checkpoint.bin");
tokio::fs::write(&path, partial.marshal_msg().expect("serialize partial checkpoint"))
.await
.expect("persist partial checkpoint");
let mut cache =
DataUsageCache::unmarshal(&tokio::fs::read(&path).await.expect("read cold checkpoint")).expect("reload cold checkpoint");
let identity = cache.info.scan_identity.expect("checkpoint identity");
let source = cache.info.source.expect("checkpoint source");
let plan = crate::DataUsageScanPlanDigest([31; 32]);
assert_eq!(
cache.prepare_bucket_checkpoint("bucket", 2, 1, source, plan, identity),
crate::data_usage_define::DataUsageCachePrepareOutcome::Reused
);
let cold_disk = open_fixture_disk(&disk_root).await;
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(
&parent,
ScannerCycleBudgetConfig {
max_entries: Some(1),
..Default::default()
},
);
let result = scan_data_folder(
budget.token(),
budget,
vec![cold_disk.clone()],
cold_disk.clone(),
cache,
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await;
let Err(ScannerError::PartialCache(partial)) = result else {
panic!("one newly charged entry must stop the cold continuation");
};
let resumed = serde_json::to_value(&partial.info.scan_directory_work[0]).expect("resumed directory receipt");
assert_eq!(
resumed["entries_read"], 17,
"the cold reader must continue after its saved native position"
);
assert_eq!(resumed["physical"], saved["physical"]);
let mut cache = DataUsageCache::unmarshal(&partial.marshal_msg().expect("serialize resumed checkpoint"))
.expect("reload resumed checkpoint");
cache.prepare_bucket_checkpoint("bucket", 3, 2, source, plan, identity);
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(&parent, ScannerCycleBudgetConfig::default());
let complete = scan_data_folder(
budget.token(),
budget,
vec![cold_disk.clone()],
cold_disk,
cache,
None,
HealScanMode::Normal,
SCANNER_SLEEPER.clone(),
)
.await
.expect("cold continuation finishes the bucket");
let total = complete.checked_flatten("bucket").expect("complete bucket root");
assert_eq!((total.objects, total.size), (64, 64));
assert!(complete.info.snapshot_complete);
}
#[cfg(any(target_os = "linux", target_os = "macos"))]
#[tokio::test]
#[serial]
async fn changed_directory_listing_clears_its_physical_receipt() {
use super::super::directory_cursor::{DirectoryScope, ScannerDirectory};
let temp = tempfile::tempdir().expect("fixture directory");
let disk_root = temp.path().join("disk");
let cache = seed_flat_bucket(&disk_root, 16).await;
let disk = open_fixture_disk(&disk_root).await;
let scope = DirectoryScope::new(&disk, &cache, FolderScanMode::Namespace, None).expect("directory scope");
let parent = CancellationToken::new();
let budget = ScannerCycleBudget::new_with_progress_tracking(&parent, ScannerCycleBudgetConfig::default());
let saved = Arc::new(std::sync::Mutex::new(None));
let path = disk_root.join("bucket");
let mut directory =
ScannerDirectory::open(path.to_str().expect("fixture path"), "bucket", Some(scope), budget, Some(saved.clone()))
.await
.expect("open physical directory");
for _ in 0..8 {
directory
.peek_entry()
.await
.expect("read physical entry")
.expect("directory member");
directory.accept_entry();
}
directory.work().expect("indexed directory").checkpoint();
assert!(saved.lock().expect("receipt").is_some());
tokio::fs::rename(&path, disk_root.join("retired"))
.await
.expect("replace physical directory");
tokio::fs::create_dir(&path).await.expect("create successor directory");
let error = directory.verify_current().await.expect_err("the old listing is invalid");
assert_eq!(error.kind(), std::io::ErrorKind::Interrupted);
drop(directory);
assert!(
saved.lock().expect("receipt").is_none(),
"an invalid listing cannot retain a resumable receipt"
);
}
-7
View File
@@ -1844,7 +1844,6 @@ pub(crate) struct ScannerCycleResult {
usage_watch_proofs: Vec<ScannerUsageWatchProof>,
usage_watch_retirements: Vec<ScannerUsageWatchProof>,
pub(crate) status: ScannerCycleStatus,
pub(crate) partial_stage: Option<&'static str>,
publication_epoch: Option<u64>,
activity_digest: Option<[u8; 32]>,
activity_baseline: Option<Arc<crate::scanner::ScannerActivitySnapshot>>,
@@ -1871,7 +1870,6 @@ impl ScannerCycleResult {
usage_watch_proofs: Vec::new(),
usage_watch_retirements: Vec::new(),
status,
partial_stage: None,
publication_epoch: None,
activity_digest: None,
activity_baseline: None,
@@ -1893,11 +1891,6 @@ impl ScannerCycleResult {
}
}
fn with_partial_stage(mut self, stage: Option<&'static str>) -> Self {
self.partial_stage = stage;
self
}
pub(crate) fn with_publication_epoch(mut self, publication_epoch: Option<u64>) -> Self {
self.publication_expectation = None;
self.publication_epoch = publication_epoch;
+2 -3
View File
@@ -862,7 +862,6 @@ pub(super) fn completed_data_usage_info(
cancelled: bool,
) -> Option<(DataUsageInfo, SystemTime)> {
completed_usage_candidate(results, scope, tier_registry_names, bucket_plan_complete, cancelled)
.ok()
.map(|candidate| (candidate.data, candidate.last_update))
}
@@ -881,7 +880,7 @@ pub(super) fn completed_usage_candidate(
tier_registry_names: &[String],
bucket_plan_complete: bool,
cancelled: bool,
) -> std::result::Result<ValidatedUsageCandidate, CandidateOutcome> {
) -> Option<ValidatedUsageCandidate> {
let candidate: std::result::Result<ValidatedUsageCandidate, CandidateOutcome> = (|| {
if !bucket_plan_complete {
return Err(CandidateOutcome::InventoryIncomplete);
@@ -1005,7 +1004,7 @@ pub(super) fn completed_usage_candidate(
Err(outcome) => *outcome,
},
);
candidate
candidate.ok()
}
fn tier_accounting_proof_is_publishable(
+25 -54
View File
@@ -15,9 +15,6 @@ use super::*;
/// ScannerIOCache implementation for SetDisks: bucket ordering, worker fan-out, merge, and publish.
use crate::data_usage_define::clone_cache_value;
mod walker_slots;
use walker_slots::AvailableWalkers;
pub(super) async fn collect_completed_bucket_results(
ctx: CancellationToken,
mut cache: DataUsageCache,
@@ -993,12 +990,12 @@ impl ScannerIOCache for SetDisks {
if turn_bucket_count == 0 {
bucket_work_complete.cancel();
}
let walker_count = walkers.len();
let available_walkers = Arc::new(AvailableWalkers::new(walkers, |disk| {
crate::storage_api::owner::EcstoreDiskAPI::endpoint(disk.as_ref()).to_string()
}));
for _ in 0..walker_count {
let available_walkers = available_walkers.clone();
for NamespaceScannerWalker {
disk,
mode: worker_mode,
local_admission,
} in walkers
{
let service_cohort_clone = service_cohort.clone();
let usage_watch_cohort_clone = usage_watch_cohort.clone();
let usage_watch_store_clone = usage_watch_store.clone();
@@ -1030,18 +1027,18 @@ impl ScannerIOCache for SetDisks {
let worker_retired_buckets = retired_buckets.clone();
#[cfg(feature = "e2e-test-hooks")]
let worker_incarnations = current_bucket_incarnations.clone();
let remote_capabilities = match worker_mode {
NamespaceScannerWorkerMode::RemoteV4(capabilities) => Some(capabilities),
NamespaceScannerWorkerMode::Coordinator => None,
};
#[cfg(test)]
let worker_index = futs.len();
futs.push(AbortOnDropHandle::new(tokio::spawn(async move {
#[cfg(test)]
super::tests::observe_coordinator_bucket_worker_started(worker_index).await;
// Returning at the top of the loop keeps the retiring disk unavailable
// on every break, cancellation, or panic, including after requeue.
let mut previous_walker = None;
let remote_session_id = uuid::Uuid::new_v4();
let mut remote_session_sequence = 0_u64;
loop {
if let Some(slot) = previous_walker.take() {
available_walkers.release(slot);
}
// Do not prefetch a FIFO member into an independently
// scheduled permit waiter: that can reorder admissions.
let permit_wait_start = Instant::now();
@@ -1054,39 +1051,18 @@ impl ScannerIOCache for SetDisks {
break;
}
let permit_wait_elapsed = permit_wait_start.elapsed();
let (bucket, slot) = tokio::select! {
let bucket = tokio::select! {
_ = bucket_work_complete_clone.cancelled() => break,
_ = ctx_clone.cancelled() => break,
selected = async {
let mut receiver = bucket_rx_mutex_clone.lock().await;
let bucket = receiver.recv().await?;
// Select while still owning FIFO admission, so the oldest bucket
// gets its preferred disk before later waiters can borrow it.
let parked = crate::scanner_folder::parked_bucket_disks(&bucket.name);
let slot = available_walkers.take_for_bucket(&bucket.name, |disk| {
parked.iter().any(|owner| owner.ptr_eq(&Arc::downgrade(disk)))
});
Some((bucket, slot))
} => match selected {
Some(pair) => pair,
None => break,
bucket = async { bucket_rx_mutex_clone.lock().await.recv().await } => {
let Some(bucket) = bucket else {
break;
};
bucket
}
};
let mut work_guard =
BucketWorkGuard::new(remaining_bucket_work_clone.clone(), bucket_work_complete_clone.clone());
let Some(slot) = slot else {
// Each live queue consumer owns at most one walker. On retirement a
// consumer and its last walker leave together.
record_failed_dirty_bucket(&failed_dirty_buckets_clone, &bucket.name).await;
break;
};
let slot = previous_walker.insert(slot);
let disk = slot.walker.disk.clone();
let local_admission = &slot.walker.local_admission;
let remote_capabilities = match slot.walker.mode {
NamespaceScannerWorkerMode::RemoteV4(capabilities) => Some(capabilities),
NamespaceScannerWorkerMode::Coordinator => None,
};
// Prefix hints are process-local. Never hand one to a
// remote or legacy-coordinator disk path.
let prefix_scan_scope = disk.is_local().then(|| scope_clone.prefix_scope_for(&bucket.name)).flatten();
@@ -1206,8 +1182,8 @@ impl ScannerIOCache for SetDisks {
let bucket_checkpoint_plan_digest = bucket_plans.coverage;
if let Some(capabilities) = remote_capabilities {
let request_sequence = slot.remote_session_sequence;
let Some(next_sequence) = request_sequence.checked_add(1) else {
let request_sequence = remote_session_sequence;
let Some(next_sequence) = remote_session_sequence.checked_add(1) else {
record_failed_dirty_bucket(&failed_dirty_buckets_clone, &bucket.name).await;
error!(
target: "rustfs::scanner::io",
@@ -1220,7 +1196,7 @@ impl ScannerIOCache for SetDisks {
);
break;
};
slot.remote_session_sequence = next_sequence;
remote_session_sequence = next_sequence;
let remote_scan = crate::remote_scanner::scan_remote_bucket(
&disk,
if capabilities.supports_durable_progress || capabilities.supports_complete_observation || capabilities.supports_usage_watch {
@@ -1234,7 +1210,7 @@ impl ScannerIOCache for SetDisks {
next_cycle: want_cycle,
leader_epoch,
server_epoch: capabilities.server_epoch,
session_id: slot.remote_session_id,
session_id: remote_session_id,
session_sequence: request_sequence,
plans: bucket_plans,
supports_durable_progress: capabilities.supports_durable_progress,
@@ -1427,7 +1403,7 @@ impl ScannerIOCache for SetDisks {
continue;
}
let _local_admission = if let Some(share) = local_admission {
let _local_admission = if let Some(share) = &local_admission {
match share.acquire(&disk) {
Ok(admission) => Some(admission),
Err(e) => {
@@ -1510,13 +1486,8 @@ impl ScannerIOCache for SetDisks {
};
let mut cache = DataUsageCache::default();
let mut revisions = match Box::pin(cache.load_for_scan(store_clone_clone.clone(), &cache_name, &scan_ctx, &bucket_budget)).await {
Ok(Some(revisions)) => revisions,
Ok(None) => {
work_guard.mark_service_interrupted();
record_partial_dirty_bucket(&partial_dirty_buckets_clone, &bucket.name).await;
continue;
}
let mut revisions = match cache.load_with_revisions(store_clone_clone.clone(), &cache_name).await {
Ok(revisions) => revisions,
Err(e) => {
record_failed_dirty_bucket(&failed_dirty_buckets_clone, &bucket.name).await;
error!(
@@ -1,128 +0,0 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::NamespaceScannerWalker;
use sha2::{Digest as _, Sha256};
use std::sync::Mutex;
use uuid::Uuid;
/// All state belonging to one physical walker travels with it, even when a
/// different queue consumer makes the next request on that endpoint.
pub(super) struct WalkerSlot<T> {
pub(super) walker: NamespaceScannerWalker<T>,
pub(super) remote_session_id: Uuid,
pub(super) remote_session_sequence: u64,
endpoint: String,
}
pub(super) struct AvailableWalkers<T>(Mutex<Vec<WalkerSlot<T>>>);
impl<T> AvailableWalkers<T> {
pub(super) fn new(walkers: Vec<NamespaceScannerWalker<T>>, endpoint: impl Fn(&T) -> String) -> Self {
Self(Mutex::new(
walkers
.into_iter()
.map(|walker| WalkerSlot {
endpoint: endpoint(&walker.disk),
walker,
remote_session_id: Uuid::new_v4(),
remote_session_sequence: 0,
})
.collect(),
))
}
/// Rank available physical endpoints independently of random inventory
/// order, waiter wakeups or the number of walker slots on a local disk.
pub(super) fn take_for_bucket(&self, bucket: &str, parked: impl Fn(&T) -> bool) -> Option<WalkerSlot<T>> {
let mut idle = self.0.lock().unwrap_or_else(|err| err.into_inner());
let mut prefix = Sha256::new();
prefix.update(bucket.as_bytes());
prefix.update([0]);
let index = idle
.iter()
.enumerate()
.map(|(index, slot)| {
let rank = prefix.clone().chain_update(slot.endpoint.as_bytes()).finalize();
(parked(&slot.walker.disk), rank, slot.endpoint.as_str(), index)
})
.max()
.map(|(_, _, _, index)| index)?;
Some(idle.swap_remove(index))
}
pub(super) fn release(&self, slot: WalkerSlot<T>) {
self.0.lock().unwrap_or_else(|err| err.into_inner()).push(slot);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::scanner_io::NamespaceScannerWorkerMode;
fn pool(endpoints: &[&'static str]) -> AvailableWalkers<&'static str> {
let walkers = endpoints
.iter()
.copied()
.map(|disk| NamespaceScannerWalker {
disk,
mode: NamespaceScannerWorkerMode::Coordinator,
local_admission: None,
})
.collect();
AvailableWalkers::new(walkers, |disk| (*disk).to_owned())
}
#[test]
fn bucket_resumes_on_same_free_endpoint_despite_reordering_or_borrower_changes() {
let first = pool(&["disk-c", "disk-a", "disk-b"]);
let reordered = pool(&["disk-b", "disk-c", "disk-a"]);
for bucket in ["wide", "documents", "snapshots", "videos"] {
let mut preferred = first.take_for_bucket(bucket, |_| false).expect("preferred walker");
let another = reordered
.take_for_bucket(bucket, |_| false)
.expect("reordered preferred walker");
assert_eq!(preferred.endpoint, another.endpoint);
let next = first
.take_for_bucket(bucket, |_| false)
.expect("fallback when primary is busy");
assert_ne!(preferred.endpoint, next.endpoint);
let alternative = next.endpoint.clone();
let id = preferred.remote_session_id;
preferred.remote_session_sequence += 1;
let sequence = preferred.remote_session_sequence;
first.release(preferred);
let resumed = first.take_for_bucket(bucket, |_| false).expect("released primary");
assert_eq!((resumed.remote_session_id, resumed.remote_session_sequence), (id, sequence));
first.release(resumed);
first.release(next);
let parked = first
.take_for_bucket(bucket, |disk| *disk == alternative)
.expect("parked directory");
assert_eq!(parked.endpoint, alternative, "follow a parked stream on a previous fallback disk");
first.release(parked);
reordered.release(another);
}
}
#[test]
fn retired_slot_leaves_same_endpoint_alternative_and_does_not_leak() {
let slots = pool(&["disk-a", "disk-a"]);
let retiring = slots.take_for_bucket("wide", |_| false).expect("first walker");
let survivor = slots.take_for_bucket("wide", |_| false).expect("second local walker");
assert!(slots.take_for_bucket("wide", |_| false).is_none());
assert_ne!(retiring.remote_session_id, survivor.remote_session_id);
let id = survivor.remote_session_id;
drop(retiring);
slots.release(survivor);
assert_eq!(
slots
.take_for_bucket("wide", |_| false)
.expect("surviving walker")
.remote_session_id,
id
);
assert!(slots.take_for_bucket("wide", |_| false).is_none());
}
}
+7 -99
View File
@@ -41,48 +41,6 @@ struct CollectorSlotSummary<'a> {
source_difference_sample: Option<CollectorSlotSample<'a>>,
}
impl CollectorSlotSummary<'_> {
/// Select one observed blocker. A source emitted in a different slot is valid when the set of sources matches.
fn partial_stage(
&self,
bucket_plan_complete: bool,
bucket_scan_status: ScannerBucketScanStatus,
dirty_usage_status: DirtyUsageSnapshotStatus,
scan_scope_matches: bool,
candidate_rejection: Option<rustfs_scanner_metrics::usage_candidate::ScannerUsageCandidateOutcome>,
) -> &'static str {
if !bucket_plan_complete {
"inventory_incomplete"
} else if self.unobserved > 0 {
"source_result_missing"
} else if bucket_scan_status == ScannerBucketScanStatus::Failed {
"bucket_worker_failed"
} else if bucket_scan_status == ScannerBucketScanStatus::NamespaceNotFound {
"bucket_namespace_not_found"
} else if bucket_scan_status == ScannerBucketScanStatus::Partial {
"bucket_walk_incomplete"
} else if dirty_usage_status == DirtyUsageSnapshotStatus::Unverified {
"dirty_generation_unverified"
} else if self.missing_source > 0 {
"missing_source"
} else if self.cycle_mismatch > 0 {
"source_cycle_mismatch"
} else if self.epoch_mismatch > 0 {
"source_epoch_mismatch"
} else if self.missing_plan > 0 || self.plan_mismatch > 0 {
"source_plan_mismatch"
} else if !scan_scope_matches {
"source_membership"
} else if self.incomplete > 0 {
"source_snapshot_incomplete"
} else if self.missing_last_update > 0 {
"missing_last_update"
} else {
candidate_rejection.map_or("root_coverage_incomplete", |outcome| outcome.as_label())
}
}
}
fn summarize_collector_slots<'a>(
slots: impl IntoIterator<Item = (usize, DataUsageCacheSource, bool, &'a DataUsageCache)>,
cycle: u64,
@@ -855,9 +813,7 @@ where
if all_buckets.is_empty() {
reset_set_scan_gauges();
if !bucket_plan_complete {
return Ok(ScannerCycleResult::new(ScannerCycleStatus::Incomplete, None)
.with_partial_stage(Some("inventory_incomplete"))
.with_publication_epoch(publication_epoch));
return Ok(ScannerCycleResult::new(ScannerCycleStatus::Incomplete, None).with_publication_epoch(publication_epoch));
}
let publication_blocked = store.scanner_data_usage_publication_blocked().await;
let activity_after = probe_scanner_cycle_activity(
@@ -894,9 +850,7 @@ where
tier_registry_generation: Some(tier_registry_generation),
},
) else {
return Ok(ScannerCycleResult::new(ScannerCycleStatus::Incomplete, None)
.with_partial_stage(Some("empty_namespace_guard"))
.with_publication_epoch(publication_epoch));
return Ok(ScannerCycleResult::new(ScannerCycleStatus::Incomplete, None).with_publication_epoch(publication_epoch));
};
let (empty_usage, publication_expectation) = candidate.prepare(status, &pending_buckets);
let usage_update_emitted = if should_publish_observational_snapshot(status) {
@@ -905,11 +859,7 @@ where
publish_usage_snapshot(&updates, status, &pending_buckets, empty_usage).await?
};
if !usage_update_emitted {
let partial_stage =
(dirty_usage_status == DirtyUsageSnapshotStatus::Unverified).then_some("dirty_generation_unverified");
return Ok(ScannerCycleResult::new(status, None)
.with_partial_stage(partial_stage)
.with_publication_epoch(publication_epoch));
return Ok(ScannerCycleResult::new(status, None).with_publication_epoch(publication_epoch));
}
if status == ScannerCycleStatus::Complete {
complete_tier_registry_cycle(want_cycle, leader_epoch);
@@ -952,9 +902,7 @@ where
"Scanner set state update detected missing disk sets"
);
reset_set_scan_gauges();
return Ok(ScannerCycleResult::new(ScannerCycleStatus::Incomplete, None)
.with_partial_stage(Some("source_inventory_empty"))
.with_publication_epoch(publication_epoch));
return Ok(ScannerCycleResult::new(ScannerCycleStatus::Incomplete, None).with_publication_epoch(publication_epoch));
}
let dispatch_limit = scanner_max_concurrent_set_scans(total_results);
@@ -1330,7 +1278,7 @@ where
remote_certification_attempted,
);
let all_bucket_names = all_buckets.iter().map(|bucket| bucket.name.clone()).collect::<Vec<_>>();
let completed_candidate = completed_usage_candidate(
let mut completed_usage = completed_usage_candidate(
&results,
&ScannerSnapshotScope {
sources: &expected_sources,
@@ -1347,8 +1295,6 @@ where
bucket_plan_complete,
owner_ctx.is_cancelled(),
);
let candidate_rejection = completed_candidate.as_ref().err().copied();
let mut completed_usage = completed_candidate.ok();
if let (Some(candidate), Some(baseline)) = (
completed_usage.as_mut(),
persisted_usage_baseline
@@ -1379,11 +1325,7 @@ where
dirty_usage_status,
activity_status,
);
let partial_stage = if cycle_status == ScannerCycleStatus::Incomplete
&& result.is_ok()
&& !budget_elapsed
&& !owner_ctx.is_cancelled()
{
if cycle_status == ScannerCycleStatus::Incomplete && result.is_ok() && !budget_elapsed && !owner_ctx.is_cancelled() {
let slots =
set_disks
.iter()
@@ -1394,35 +1336,6 @@ where
(index, DataUsageCacheSource::new(set.pool_index, set.set_index), *observed, snapshot)
});
let summary = summarize_collector_slots(slots, want_cycle, leader_epoch, scan_plan_digest);
let mut stage = summary.partial_stage(
bucket_plan_complete,
bucket_scan_status,
dirty_usage_status,
scan_scope_matches,
candidate_rejection,
);
// A fully traversed mixed-plan observation needs another certification sweep. Only
// attribute the stop to that fence when every uncarried bucket has fresh source evidence.
if stage == "bucket_walk_incomplete"
&& let Some((snapshot, _)) = &observational_usage
&& partial_buckets.difference(&carried_partial_buckets).all(|bucket| {
snapshot
.usage_snapshot_bucket_observations
.get(bucket)
.is_some_and(|observation| {
observation
.sources
.iter()
.all(|source| source.scanner_epoch == leader_epoch && source.scanner_cycle == want_cycle)
&& observation
.sources
.iter()
.any(|source| source.started_plan != source.requested_plan)
})
})
{
stage = "mixed_plan_recertification_pending";
}
let sample = summary.sample;
let source_difference = summary.source_difference_sample;
let sample_snapshot = sample.filter(|sample| sample.observed).map(|sample| sample.snapshot);
@@ -1432,7 +1345,6 @@ where
component = LOG_COMPONENT_SCANNER,
subsystem = LOG_SUBSYSTEM_IO,
state = "incomplete_cycle_collector_summary",
partial_stage = stage,
cycle = want_cycle,
leader_epoch,
configured_sets = set_disks.len(),
@@ -1478,10 +1390,7 @@ where
sample_snapshot_plan_matches = sample_snapshot.and_then(|snapshot| snapshot.info.scan_plan_digest.map(|plan| plan == scan_plan_digest)),
"Scanner recorded collector observations for an incomplete cycle"
);
Some(stage)
} else {
None
};
}
// Certification is per bucket: the pending set is read after the
// guardrail verdict so a bucket written during the walk is reported in
// the same publication that certifies the others. A bucket whose walk
@@ -1674,7 +1583,6 @@ where
complete_tier_registry_cycle(want_cycle, leader_epoch);
}
Ok(ScannerCycleResult::new(cycle_status, dirty_usage_clear)
.with_partial_stage(partial_stage)
.with_usage_watch_proofs(usage_watch_proofs.into_values().collect())
.with_usage_watch_retirements(usage_watch_retirements)
.with_publication_epoch(publication_epoch)
@@ -127,8 +127,6 @@ async fn collector_reports_an_unobserved_slot_after_a_stale_set_snapshot() {
let events = collector_events(&events);
assert_eq!(events.len(), 1, "a non-budget incomplete cycle needs one collector observation");
let fields = events[0];
assert_eq!(fields["partial_stage"], "source_result_missing");
assert_eq!(result.partial_stage, Some("source_result_missing"));
assert_eq!(fields["cycle"], 7);
assert_eq!(fields["leader_epoch"], LEADER_EPOCH);
assert_eq!(fields["expected_sources"], 1);
@@ -173,7 +171,6 @@ async fn collector_reports_received_incomplete_cache_only_for_non_budget_partial
let events = collector_events(&events);
assert_eq!(events.len(), 1, "a non-budget incomplete cycle needs one collector observation");
let fields = events[0];
assert_eq!(fields["partial_stage"], second.partial_stage.expect("non-budget incomplete stage"));
assert_eq!(fields["observed_slots"], 1);
assert_eq!(fields["unobserved_slots"], 0);
assert_eq!(fields["sample_observed"], true);
@@ -190,7 +187,6 @@ async fn collector_reports_received_incomplete_cache_only_for_non_budget_partial
let ((third, snapshot, _), events) = capture_cycle(run_cycle(&store, 3, None, false)).await;
assert_eq!(third.status, ScannerCycleStatus::Complete);
assert_eq!(third.partial_stage, None);
assert!(snapshot.is_some_and(|snapshot| snapshot.usage_snapshot_complete));
assert!(
collector_events(&events).is_empty(),
@@ -15,6 +15,30 @@
use super::*;
use crate::data_usage_define::{DATA_USAGE_OBJ_NAME_PATH, read_config_with_revision};
// Two-pool EC fixtures keep many scan futures live at once and overflow
// Linux libtest's default 2 MiB test-thread stack. Run each case on a
// dedicated 32 MiB thread (same approach as scoped_entry_fallback).
fn run_cohort_test<F, Fut>(thread_name: &'static str, test_fn: F)
where
F: FnOnce() -> Fut + Send + 'static,
Fut: std::future::Future<Output = ()> + 'static,
{
let handle = std::thread::Builder::new()
.name(thread_name.to_string())
.stack_size(32 * 1024 * 1024)
.spawn(move || {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("service cohort test runtime should build");
runtime.block_on(test_fn());
})
.expect("service cohort test thread should spawn");
if let Err(payload) = handle.join() {
std::panic::resume_unwind(payload);
}
}
async fn create_cohort_bucket(store: &ECStore, bucket: &str) {
create_cohort_bucket_objects(store, bucket, 1).await;
}
@@ -104,9 +128,16 @@ async fn run_cohort_cycle(
(result, usage)
}
#[tokio::test]
#[test]
#[serial]
async fn service_cohort_production_dispatch_services_waiters_across_sources() {
fn service_cohort_production_dispatch_services_waiters_across_sources() {
run_cohort_test(
"cohort-prod-disp",
service_cohort_production_dispatch_services_waiters_across_sources_case,
);
}
async fn service_cohort_production_dispatch_services_waiters_across_sources_case() {
let (_dir, store) = setup_two_pool_scanner_store().await;
clear_dirty_usage_buckets_for_tests();
let hot = format!("a-hot-{}", Uuid::new_v4().simple());
@@ -197,9 +228,16 @@ async fn service_cohort_production_dispatch_services_waiters_across_sources() {
clear_dirty_usage_buckets_for_tests();
}
#[tokio::test]
#[test]
#[serial]
async fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket() {
fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket() {
run_cohort_test(
"cohort-flat-bud",
service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket_case,
);
}
async fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_bucket_case() {
let (_dir, store) = setup_two_pool_scanner_store().await;
clear_dirty_usage_buckets_for_tests();
let flat = format!("a-flat-{}", Uuid::new_v4().simple());
@@ -283,9 +321,16 @@ async fn service_cohort_flat_bucket_budget_does_not_publish_unscanned_small_buck
clear_dirty_usage_buckets_for_tests();
}
#[tokio::test]
#[test]
#[serial]
async fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources() {
fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources() {
run_cohort_test(
"cohort-fresh-agg",
service_cohort_fresh_complete_aggregate_preserves_reordered_sources_case,
);
}
async fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources_case() {
let (_dir, store) = setup_two_pool_scanner_store().await;
clear_dirty_usage_buckets_for_tests();
for bucket in ["cohort-first", "cohort-second"] {
@@ -329,9 +374,16 @@ async fn service_cohort_fresh_complete_aggregate_preserves_reordered_sources() {
clear_dirty_usage_buckets_for_tests();
}
#[tokio::test]
#[test]
#[serial]
async fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits() {
fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits() {
run_cohort_test(
"cohort-cancelled",
service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits_case,
);
}
async fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_permits_case() {
let (_dir, store) = setup_two_pool_scanner_store().await;
clear_dirty_usage_buckets_for_tests();
let bucket = format!("cancel-{}", Uuid::new_v4().simple());
@@ -360,9 +412,16 @@ async fn service_cohort_cancelled_dispatch_does_not_consume_waiters_or_leak_perm
/// N=17, q=4: every bucket reaches a worker within ceil(17/4)=5 rounds while
/// one bucket stays hot and another fails forever, with leader-local state
/// discarded after each round as a restart would.
#[tokio::test]
#[test]
#[serial]
async fn cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket() {
fn cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket() {
run_cohort_test(
"cold-svc-bound",
cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket_case,
);
}
async fn cold_bucket_service_bound_survives_restart_with_hot_and_failing_bucket_case() {
const BUCKETS: usize = 17;
const QUANTA: u64 = 4;
const ROUND_BOUND: usize = 5;
@@ -434,9 +493,16 @@ fn quantum_budget(quantum: crate::scanner_budget::ScannerBucketQuantum) -> Arc<S
)
}
#[tokio::test]
#[test]
#[serial]
async fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots() {
fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots() {
run_cohort_test(
"src-turn-disp",
source_turn_dispatch_rotates_real_sources_and_retains_completed_roots_case,
);
}
async fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots_case() {
let mut evidence = None;
temp_env::async_with_vars([(ENV_SCANNER_MAX_CONCURRENT_SET_SCANS, Some("1"))], async {
crate::runtime_config::refresh_scanner_runtime_config_for_tests();
@@ -503,9 +569,16 @@ async fn source_turn_dispatch_rotates_real_sources_and_retains_completed_roots()
);
}
#[tokio::test]
#[test]
#[serial]
async fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources() {
fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources() {
run_cohort_test(
"src-turn-zero",
source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources_case,
);
}
async fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_sources_case() {
temp_env::async_with_vars([(ENV_SCANNER_MAX_CONCURRENT_SET_SCANS, Some("1"))], async {
crate::runtime_config::refresh_scanner_runtime_config_for_tests();
let (_dir, store) = setup_two_pool_scanner_store().await;
@@ -533,9 +606,13 @@ async fn source_turn_zero_new_frontier_stops_requeuing_without_starving_other_so
crate::runtime_config::refresh_scanner_runtime_config_for_tests();
}
#[tokio::test]
#[test]
#[serial]
async fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets() {
fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets() {
run_cohort_test("fair-spent-qm", fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets_case);
}
async fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets_case() {
let (_dir, store) = setup_local_scanner_store(1, 4).await;
clear_dirty_usage_buckets_for_tests();
create_cohort_bucket_objects(&store, "a-flat", 6).await;
@@ -565,9 +642,13 @@ async fn fair_prefix_quantum_spent_bucket_returns_behind_waiting_buckets() {
clear_dirty_usage_buckets_for_tests();
}
#[tokio::test]
#[test]
#[serial]
async fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn() {
fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn() {
run_cohort_test("fair-no-motion", fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn_case);
}
async fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn_case() {
let (_dir, store) = setup_local_scanner_store(1, 4).await;
clear_dirty_usage_buckets_for_tests();
create_cohort_bucket_objects(&store, "a-flat", 6).await;
@@ -590,9 +671,16 @@ async fn fair_prefix_quantum_without_durable_motion_ends_the_bucket_turn() {
/// A one-object share stops inside its first child, so the frontier never
/// moves. Requeuing that bucket would spin until the cycle deadline.
#[tokio::test]
#[test]
#[serial]
async fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing() {
fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing() {
run_cohort_test(
"fair-rep-share",
fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing_case,
);
}
async fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeuing_case() {
let (_dir, store) = setup_local_scanner_store(1, 4).await;
clear_dirty_usage_buckets_for_tests();
create_cohort_bucket_objects(&store, "a-flat", 3).await;
@@ -613,9 +701,16 @@ async fn fair_prefix_quantum_repeated_share_without_a_new_frontier_stops_requeui
clear_dirty_usage_buckets_for_tests();
}
#[tokio::test]
#[test]
#[serial]
async fn cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners() {
fn cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners() {
run_cohort_test(
"cold-saved-ord",
cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners_case,
);
}
async fn cold_bucket_service_saved_order_keeps_coverage_and_rejects_older_owners_case() {
let (_dir, store) = setup_local_scanner_store(1, 4).await;
clear_dirty_usage_buckets_for_tests();
create_cohort_bucket(&store, "cold-only").await;
@@ -82,9 +82,7 @@ fn completed_outcome(
},
};
assert_one_outcome(Kind::Completed, outcome, || {
let candidate = completed_usage_candidate(caches, &scope, &[], plan_complete, owner_cancelled);
assert_eq!(candidate.as_ref().err().copied().unwrap_or(Outcome::Accepted), outcome);
candidate.ok()
completed_usage_candidate(caches, &scope, &[], plan_complete, owner_cancelled)
});
}
+3 -8
View File
@@ -30,12 +30,11 @@ doctest = false
[features]
default = []
hotpath = ["hotpath/hotpath", "hotpath/tokio", "rustfs-rio/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc", "rustfs-rio/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu", "rustfs-rio/hotpath-cpu"]
hotpath = ["rustfs-rio/hotpath"]
hotpath-alloc = ["hotpath", "rustfs-rio/hotpath-alloc"]
hotpath-cpu = ["hotpath", "rustfs-rio/hotpath-cpu"]
[dependencies]
hotpath.workspace = true
async-compression = { workspace = true, features = [
"tokio",
"bzip2",
@@ -49,10 +48,6 @@ rustfs-rio.workspace = true
tokio = { workspace = true, features = ["io-util", "macros", "rt"] }
thiserror = { workspace = true }
[target.'cfg(target_os = "macos")'.dependencies]
# Keep XZ decoding self-contained in macOS binaries instead of linking Homebrew liblzma.
liblzma = { version = "0.4.9", features = ["static"] }
[dev-dependencies]
rustfs-tokio-tar = { workspace = true }
futures = { workspace = true }
+7 -5
View File
@@ -29,14 +29,16 @@ zdict_builder = ["zstd_fixed/zdict_builder"]
zstdmt = ["zstd_fixed/zstdmt"]
[dev-dependencies]
# Enables zstd-safe's `seekable` feature for tests/security.rs. The test imports
# `zstd_safe::seekable` directly so cargo-shear treats this as a used dependency.
zstd-safe = { version = "8.3.0", features = ["seekable"] }
toml = "1.2.1"
toml = "1.2.2"
semver = "1.0.28"
apache-avro.workspace = true
arrow-array = "60.1.0"
arrow-ipc = { version = "60.1.0", features = ["zstd"] }
arrow-schema = "60.1.0"
parquet = { version = "60.1.0", default-features = false, features = ["arrow", "zstd"] }
arrow-array = "60.2.0"
arrow-ipc = { version = "60.2.0", features = ["zstd"] }
arrow-schema = "60.2.0"
parquet = { version = "60.2.0", default-features = false, features = ["arrow", "zstd"] }
kafka-protocol = { version = "0.18.0", default-features = false, features = ["zstd"] }
bytes.workspace = true
+1 -1
View File
@@ -86,7 +86,7 @@ fn corrupt_legacy_frame_cannot_emit_bytes_when_writer_is_dropped() {
#[test]
fn seekable_offsets_past_eof_keep_vec_length_within_capacity() {
use zstd::zstd_safe::seekable::{Seekable, SeekableCStream};
use zstd_safe::seekable::{Seekable, SeekableCStream};
let source = b"seekable frame fixture with enough data for several independent frames";
let mut encoded = [0; 1024];
+1 -1
View File
@@ -15,7 +15,7 @@ An unchanged interval requires matching owner, process session, watch token, buc
Watch renewal keeps the original starting revision. A caller may extend its conservative local monotonic deadline after a successful renewal, but it must not replace the original proof with the renewed revision. A persisted checkpoint stores identity and revision, not a usable `Instant`; after restart, the old producer token must be checked again against the complete current owner set.
One keeper belongs to each service cohort, with weak store and cohort references. After a cycle deadline the scanner supervisor retains its cohort only when the worker has stopped, cycle state has been persisted, and the epoch has been fenced. A successful successor claim on the same storage instance can resume the cohort only from the exact fenced revision and immediately following epoch. An intervening claim, lock contention, or recovery drops the continuation. The cohort preserves its bounded watch renewals and scheduling order across the retry interval. The new leader needs its own fences for publication and dirty acknowledgements. The keeper revisits retained watches every sixty seconds, with four concurrent queries and a five-second total limit per keepalive query. At the 256-watch limit one pass is bounded by 380 seconds, below the ten-minute producer lease. Retained checkpoints and finished sources awaiting root publication and ACK keep their original proof alive. A subsequent cycle may restart a cancelled keeper for the same instance, but cannot reset the original token, revision, or expired deadline.
One keeper belongs to each leader-local cohort, with weak store and cohort references. It revisits retained watches every sixty seconds, with four concurrent queries and a five-second total limit per keepalive query. At the 256-watch limit one pass is bounded by 380 seconds, below the ten-minute producer lease. Retained checkpoints and finished sources awaiting root publication and ACK keep their original proof alive. A subsequent cycle may restart a cancelled keeper for the same instance, but cannot reset the original token, revision, or expired deadline.
## Consumer and persistence order
+3 -14
View File
@@ -82,13 +82,7 @@ The startup usage preflight is read-only and has a 30-second deadline. If it can
Cold-cache startup and startup without active replication avoid an extra bucket listing. Maintenance discovery keeps looking for replication after finding lifecycle rules in an earlier bucket. Once replication is found, both scheduling decisions are settled and remaining buckets need no startup inspection. Reapplying an unchanged resolved configuration does not reconfigure per-disk budgets or emit another configuration wakeup.
The `cycle_max_duration`, `cycle_max_objects` and `cycle_max_directories` settings also apply to resumed walks. For a stable wide directory, a checkpoint records which child names have been discovered, which children have finished and the usage accumulated from those children. The next executor can restore that work after a cycle deadline or process restart. Objects from a child that was interrupted before completion are accounted for when that child finishes.
On Linux and macOS, the scanner can reopen a partially enumerated physical directory and verify its last saved position against the directory generation and actual entries. Each physical replica has its own position. A replacement or changed directory requires enumeration again. When an executor moves to another disk, it advances that disk's own checkpoint. Returning to the first disk resumes its saved subtotal. This keeps sizes and version counts tied to the replica whose object metadata was read. Other platforms can reuse a live directory handle and already completed work on an identifiable disk. An interrupted native directory read may need to start again after a process restart.
After an upgrade, an older partial traversal without a recorded physical disk starts a fresh walk. This preserves the existing published usage snapshot when the partial checkpoint is discarded. To verify a handoff, enable debug logging for `rustfs_scanner::scanner_folder::directory_cursor` and look for `state="directory_checkpoint_restored"`. The event identifies the bucket, directory, physical disk, leader epoch and cycle. `restore_mode="native_position"` records how many entries had already been read. `restore_mode="sealed_membership"` records reuse of a fully enumerated directory and includes `completed_through` when the checkpoint contains a compacted subtotal.
The bucket usage API can return a carried value or a newer observation while a walk is incomplete. Check `usage_value_state` and `usage_certification` to identify the last certified value. If writes overlap a resumed walk, reaching the end can produce an observation that still needs a fresh sweep before certification. Progress requires enough budget for individual I/O operations and a successful checkpoint save.
The `cycle_max_duration`, `cycle_max_objects`, and `cycle_max_directories` controls bound a cycle's work; they do not guarantee that every budget can complete a sweep in bounded chunks. A partial scan preserves useful checkpoints and coverage, but reopening ancestors and revalidating directory entries costs work again. A budget below the minimum replay or traversal cost can repeatedly stop at the same directory. Cross-bucket fairness also needs to be distinguished from progress within one bucket. Use pacing controls to limit background I/O, and choose cycle budgets large enough for the namespace to advance.
Budget cancellation alone does not publish complete usage or acknowledge dirty buckets. A partial cycle must retain that uncertainty; a growing directories-scanned counter is not proof of new coverage or published totals. Inspect checkpoint/frontier changes and publication status across attempts before changing budgets. A budget cancellation does not persist a disabled scheduler flag and does not justify deleting scanner state.
@@ -236,7 +230,7 @@ Only `xl.meta` files enter object metadata accounting. Other payload files consu
UUID candidates under a directory without `xl.meta` are classified during their normal directory traversal. Each directory open and entry is charged once; traversal yields every 64 entries and continues under the budget until a regular `part.N` is found or EOF is reached. A full batch is not evidence of absence. Candidate metadata accounting is deferred until classification finishes. A data directory retains the existing missing-parent-metadata and non-destructive heal path; a namespace continues from the same listing, without a second probe/open/entry pass. Data directories do not consume namespace-directory quota or a preset folder delay; a candidate proven to be a namespace consumes that quota and delay once.
Candidate entries use the normal raw-enumeration progress and checkpoint path. Cancellation or an iteration error leaves classification incomplete, never an EOF or successful coverage result. A child already absent or replaced by a non-directory at open is handled as vanished, without stale namespace totals or a missing-metadata heal request. A replacement retains the existing coverage gap; mid-iteration errors never become EOF. A clean namespace covered by a restored frontier reuses its prior totals only after current classification reaches EOF; metadata is not read or charged to object quota again. A later data candidate prevents completed namespace siblings from certifying the unresolved parent. The disk worker parks the physical enumeration between turns and checks directory identity and modification state before reuse. A cold process reopens the directory and pays for its physical reads again. Raw-page indexes identify visited names; the scanner still requires EOF, complete child accounting and a valid publication fence before certifying totals.
Candidate entries use the normal raw-enumeration progress and checkpoint path. Cancellation or an iteration error leaves classification incomplete, never an EOF or successful coverage result. A child already absent or replaced by a non-directory at open is handled as vanished, without stale namespace totals or a missing-metadata heal request. A replacement retains the existing coverage gap; mid-iteration errors never become EOF. A clean namespace covered by a restored frontier reuses its prior totals only after current classification reaches EOF; metadata is not read or charged to object quota again. A later data candidate prevents completed namespace siblings from certifying the unresolved parent. Existing raw-page indexes are membership receipts, not portable filesystem seek offsets: a later cycle or process restart reopens and revalidates the directory, with actual reads charged again. This does not guarantee that a directory larger than the configured cycle budget can finish within that budget.
- Media is detected once per disk path from the backing block device's `rotational` flag on Linux, through partitions, `dm-*`, and software RAID; any spindle in the stack counts as rotational. Undetectable media, including non-Linux hosts and overlay filesystems without a bind-mounted volume, uses the rotational defaults because a spindle is the case that needs protection.
- `auto` resolves to `100` operations/s and `16 MiB/s` on rotational or unknown media and to `4000` operations/s and `256 MiB/s` on flash. The rotational values leave roughly half of a 7200 rpm spindle's random reads to foreground traffic; the flash values are a few percent of a SATA SSD. The `fastest` speed preset resolves `auto` to no cap; explicit numbers always apply.
@@ -319,7 +313,6 @@ metrics.maintenance_control.primary_control
metrics.source_work
metrics.replication_repair
metrics.scan_checkpoint
metrics.last_cycle_partial_stage
metrics.cycle_timeout_total
metrics.cycle_last_progress_age
metrics.leader_lease_without_progress
@@ -342,8 +335,6 @@ catch_up_estimate.discovered_expiry_items
catch_up_estimate.discovered_transition_items
```
For a partial cycle, `metrics.last_cycle_partial_stage` records the blocking check for that cycle. For example, `entry_budget` counts raw directory enumeration, `source_result_missing` means an expected set supplied no result, and `activity_baseline_unverified` means the activity proof could not certify publication. A `mixed_plan_recertification_pending` stage means every outstanding bucket completed traversal and supplied a fresh cross-plan observation that still requires certification. Candidate rejections retain the existing candidate outcome labels such as `invalid_root` and `tier_proof`. The field clears on the next non-partial cycle outcome. Inspect `metrics.usage_publication` for the outcome of writing the root snapshot. When a cycle ends with incomplete coverage or an unverifiable observation, the terminal error event includes the cycle, leader epoch and blocking stage. Budget stops and saved checkpoints remain visible in scanner status and warning logs. A supervisor deadline that interrupts the worker before a terminal result increments `metrics.cycle_timeout_total`.
### Deep scan cadence state
`bitrot` reports how the scanner decided the scan mode of the running or most recent cycle:
@@ -370,8 +361,6 @@ A resumed walk retains its previous durable coverage while initial enumeration h
Shared compacted accumulators defer periodic emission until the owning subtree completes; replay inside that compacted subtree remains possible after an interruption. When bucket checkpoint preparation returns `Reset` for existing resume state, it logs `checkpoint_reset` with the validation reason. The `scan_checkpoint_used` counter includes validated coverage adoption by the forward sweep.
Fenced per-bucket checkpoints keep small payloads inline. Large checkpoints stage immutable, checksum-addressed pages and then conditionally replace a small manifest. The primary and backup use separate page objects. Interruption before the manifest write leaves the prior checkpoint readable. A staging marker identifies a new page bundle before any pages are written. If a later commit uses an inline checkpoint or a different bundle, that commit records the abandoned bundle for fenced cleanup, which a later save can retry after a restart. Cold recovery uses background disk admission, verifies the referenced pages, and can carry verified restore progress across local time slices. A reader that predates the page format can rebuild a partial checkpoint and can read compact complete totals when the compatibility projection fits the manifest.
A confirmed periodic save does not prove restart resumability. Adoption still validates bucket/set identity and, for non-empty caches, connected cache scope. Skipping completed subtrees additionally requires a validated coverage frontier; raw enumeration state alone does not prove completed subtree coverage.
### Cycle recovery on followers
@@ -947,7 +936,7 @@ For a mostly idle single-node, single-disk deployment with sustained CPU usage w
6. If `primary_pressure` is `throttle_pause` and pause ratios are low, raise `scanner.delay` first.
7. If individual sleeps are too short, raise `scanner.max_wait`.
8. If each scan cycle finishes but starts too often, raise `scanner.cycle`.
9. To bound one cycle, set `scanner.cycle_max_duration`, `scanner.cycle_max_objects`, or `scanner.cycle_max_directories`; confirm that checkpoints advance under that budget. For the conditions that permit a wide directory to advance across turns and process restarts, see [Startup and cycle budgets](#startup-and-cycle-budgets).
9. To bound one cycle, set `scanner.cycle_max_duration`, `scanner.cycle_max_objects`, or `scanner.cycle_max_directories`; confirm that checkpoints advance under that budget. These controls do not guarantee resumable bounded chunks for every directory shape; see [Startup and cycle budgets](#startup-and-cycle-budgets).
10. Recheck `pacing_pressure`, `maintenance_control`, source work, and lifecycle transition status after one or more scanner cycles.
Do not rely only on a longer cycle interval if lifecycle, replication, heal, or bitrot work must keep moving; use source work and transition status to confirm that background maintenance still progresses.
+1 -1
View File
@@ -64,7 +64,7 @@ A coverage receipt binds the completed traversal frontier to its scope, starting
The Normal-to-Deep regression holds the mutation plan fixed, changes metadata in a previously visited prefix, and verifies that the real Deep disk-scan entry point reads that prefix again. It also checks that a complete Normal cache cannot satisfy the Deep `Current` path. The fixture disables heal side effects; it proves traversal re-entry, not actual bitrot detection or repair. Additional tests cover map round-trips, stale identities, existing-but-uncovered cursors, coverage gaps, and per-instance metadata ownership.
The independent `wide_directory_runtime_budget_reaches_eof` regression charges virtual time for every physical directory read, including replay and EOF, and checks exact object and byte totals across capped rounds. The `paged_checkpoint` tests exercise immutable page reuse, interrupted root commits, stale writers and cold restoration. The process-level regression in [the E2E crate](../../crates/e2e_test/src/scanner_wide_directory_test.rs) seeds objects through S3, restarts the server after a partial save, and checks the certified admin usage against a paginated S3 listing using the same scanner budget on both boots.
This fixture bounds object processing after directory enumeration. It does not prove fixed-budget enumeration of arbitrarily wide directories or real process-restart convergence. Those gates require a storage-owned resumable enumeration capability, including its initial construction cost; a readdir offset, an in-memory iterator or a last-name filter is not that capability.
For every saved partial cache, the fixture also passes its progress through the production authenticated remote terminal-frame writer and stream consumer. A remote partial result must remain partial even when its progress reports visited objects. This covers the return-frame contract; it does not execute the remote RPC server, distributed locks, EC quorum persistence, mixed-version peers, process crashes, or fsync durability. The file backend models revision preconditions and persistence errors, not a concurrent object store.
Generated
+6 -6
View File
@@ -2,11 +2,11 @@
"nodes": {
"nixpkgs": {
"locked": {
"lastModified": 1794495034,
"narHash": "sha256-E0hYoioqUtM2XmPPvYYpJgdADF5AW9oOoPSEiM9dTHQ=",
"lastModified": 1795249095,
"narHash": "sha256-8JDgyVvWUZg5m9hNlL8Ge9aT647ng3Ukc8NPMiKNTPQ=",
"owner": "NixOS",
"repo": "nixpkgs",
"rev": "2074cc672349f14240fb7ea90d509e0b643e9dd4",
"rev": "93a9ed0a866099a230ed5146a5bb7d16fd5c9b14",
"type": "github"
},
"original": {
@@ -29,11 +29,11 @@
]
},
"locked": {
"lastModified": 1794646145,
"narHash": "sha256-rpqDyUM/d5fACYB8W+wKxxO57ICWjjalzb2X25oFFkY=",
"lastModified": 1795253373,
"narHash": "sha256-Vg6Sg8gJCDG9qpVEdOZX+72Z50MLwdnwtfZ8FNBwiYI=",
"owner": "oxalica",
"repo": "rust-overlay",
"rev": "5b87ee0513c29127a01ad06e9cb362ea5ce91e78",
"rev": "52db20539ec0ba063479d66092992d9efcf456ff",
"type": "github"
},
"original": {
+23 -24
View File
@@ -1021,31 +1021,30 @@ impl<T> S3Router<T> {
}
}
/// Dispatches one legacy admin request. Callers keep their assertions and do not name s3s.
/// Free function (not an inherent impl) so the `OwnedOperation` bound stays `pub(crate)`.
#[cfg(test)]
impl<T: OwnedOperation> S3Router<T> {
/// Dispatches one legacy admin request. Callers keep their assertions and do not name s3s.
pub(crate) async fn call_legacy(
&self,
method: Method,
uri: &str,
extensions: http::Extensions,
) -> s3s::S3Result<S3Response<Body>> {
S3Route::call(
self,
S3Request {
input: Body::empty(),
method,
uri: uri.parse().expect("test URI"),
headers: HeaderMap::new(),
extensions,
credentials: None,
region: None,
service: None,
trailing_headers: None,
},
)
.await
}
pub(crate) async fn call_legacy<T: OwnedOperation>(
router: &S3Router<T>,
method: Method,
uri: &str,
extensions: http::Extensions,
) -> s3s::S3Result<S3Response<Body>> {
S3Route::call(
router,
S3Request {
input: Body::empty(),
method,
uri: uri.parse().expect("test URI"),
headers: HeaderMap::new(),
extensions,
credentials: None,
region: None,
service: None,
trailing_headers: None,
},
)
.await
}
impl<T> Default for S3Router<T> {
+3 -5
View File
@@ -141,7 +141,7 @@ mod tests {
object_store_from_envelope, publish_test_app_context,
};
use crate::admin::operation::{AdminRequest, AdminResponse, Operation};
use crate::admin::router::S3Router;
use crate::admin::router::{S3Router, call_legacy};
use crate::app::{RequestEnvelope, RequestHead};
use hyper::{Method, StatusCode};
use matchit::Params;
@@ -323,15 +323,13 @@ mod tests {
.insert(Method::GET, "/context-probe", ContextDependentAdminRoute)
.expect("register test route");
let err = router
.call_legacy(Method::GET, "/context-probe", http::Extensions::new())
let err = call_legacy(&router, Method::GET, "/context-probe", http::Extensions::new())
.await
.expect_err("empty slot must fail closed");
assert_eq!(err.code(), &S3ErrorCode::ServiceUnavailable.into());
assert!(slot.install(distinct_context(&ambient)));
let response = router
.call_legacy(Method::GET, "/context-probe", http::Extensions::new())
let response = call_legacy(&router, Method::GET, "/context-probe", http::Extensions::new())
.await
.expect("installed slot must serve request");
assert_eq!(response.status, Some(StatusCode::NO_CONTENT));
+12 -13
View File
@@ -1320,23 +1320,22 @@ mod tests {
};
for (index, expected_key) in ["a&local", "z-local"].into_iter().enumerate() {
let request_marker = input.marker.clone().unwrap_or_default();
let list_req = 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,
};
let envelope = crate::app::RequestEnvelope::from_s3s(&list_req);
let gateway_input =
rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::list_objects::input_from_s3s(
list_req.input,
input.clone(),
)
.expect("convert ListObjectsInput");
let envelope = crate::app::RequestEnvelope::from_parts(
crate::app::RequestHead {
method: http::Method::GET,
uri: http::Uri::from_static("/"),
headers: HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
http::Extensions::new(),
);
let gateway_output = tokio::time::timeout(
Duration::from_secs(10),
DefaultBucketUsecase::from_global().execute_list_objects(envelope, gateway_input),
+2 -3
View File
@@ -509,7 +509,7 @@ impl DefaultBucketUsecase {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info};
use crate::app::bucket_usecase::test_support::{build_request_with_req_info, owned_envelope};
use crate::app::storage_api::s3::dto::CreateBucketInput;
use http::Method;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
@@ -1005,11 +1005,10 @@ mod tests {
#[tokio::test]
async fn execute_list_buckets_returns_internal_error_when_store_uninitialized() {
let req = build_request((), Method::GET);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_list_buckets(RequestEnvelope::from_s3s(&req), gateway_dto::ListBucketsInput::default())
.execute_list_buckets(owned_envelope(Method::GET), gateway_dto::ListBucketsInput::default())
.await
.unwrap_err();
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
+5 -6
View File
@@ -366,7 +366,7 @@ impl DefaultBucketUsecase {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info, s3_op_total};
use crate::app::bucket_usecase::test_support::{build_request_with_req_info, owned_envelope, s3_op_total};
use http::Method;
#[test]
@@ -399,11 +399,10 @@ mod tests {
/// The envelope of a request whose access phase installed `req_info`, or none.
fn envelope(req_info: Option<ReqInfo>) -> RequestEnvelope {
let req = match req_info {
Some(req_info) => build_request_with_req_info((), Method::PUT, req_info),
None => build_request((), Method::PUT),
};
RequestEnvelope::from_s3s(&req)
match req_info {
Some(req_info) => RequestEnvelope::from_s3s(&build_request_with_req_info((), Method::PUT, req_info)),
None => owned_envelope(Method::PUT),
}
}
#[test]
+5 -6
View File
@@ -203,7 +203,7 @@ impl DefaultBucketUsecase {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::owned_envelope;
use crate::app::storage_api::s3::dto::{self, PutBucketEncryptionInput, ServerSideEncryption};
use http::Method;
use rustfs_gateway_types::persistence::{
@@ -292,20 +292,19 @@ mod tests {
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let prepared = crate::storage::persisted_from_s3s(&req.input.server_side_encryption_configuration);
let prepared = crate::storage::persisted_from_s3s(&input.server_side_encryption_configuration);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_put_bucket_encryption(RequestEnvelope::from_s3s(&req), &req.input.bucket, prepared.map_err(Into::into))
.execute_put_bucket_encryption(owned_envelope(Method::PUT), &input.bucket, prepared.map_err(Into::into))
.await
.unwrap_err();
assert_eq!(err.code(), &S3ErrorCode::InternalError);
let err = usecase
.execute_put_bucket_encryption(
RequestEnvelope::from_s3s(&req),
&req.input.bucket,
owned_envelope(Method::PUT),
&input.bucket,
Ok(PersistedBucketEncryptionConfiguration { rules: vec![] }),
)
.await
+3 -4
View File
@@ -405,7 +405,7 @@ mod tests {
// waiter again on the single-thread test runtime.
assert_eq!(admission.available_permits(), 1);
}
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
use crate::app::runtime_sources::ServerContextSlot;
use crate::app::storage_api::bucket_usecase::helper::MutationCompletionProbe;
@@ -775,13 +775,12 @@ mod tests {
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_put_bucket_lifecycle_configuration(
RequestEnvelope::from_s3s(&req),
&req.input.bucket,
owned_envelope(Method::PUT),
&input.bucket,
PreparedLifecycleConfiguration::Missing,
)
.await
@@ -159,7 +159,7 @@ fn list_object_versions_output(
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::owned_envelope;
use rustfs_gateway_types::BucketName;
use rustfs_s3_types::S3ErrorCode;
@@ -319,7 +319,7 @@ mod tests {
};
let err = DefaultBucketUsecase::without_context()
.execute_list_object_versions(RequestEnvelope::from_s3s(&build_request((), http::Method::GET)), input)
.execute_list_object_versions(owned_envelope(http::Method::GET), input)
.await
.expect_err("a negative page size");
assert_eq!(err.code(), &S3ErrorCode::InvalidArgument);
@@ -333,7 +333,7 @@ mod tests {
};
let err = DefaultBucketUsecase::without_context()
.execute_list_object_versions(RequestEnvelope::from_s3s(&build_request((), http::Method::GET)), input)
.execute_list_object_versions(owned_envelope(http::Method::GET), input)
.await
.expect_err("no store");
assert_eq!(err.code(), &S3ErrorCode::InternalError);
@@ -372,13 +372,12 @@ fn list_objects_next_marker(info: &ListObjectsV2Info, cursor: Option<&str>) -> O
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::owned_envelope;
use rustfs_gateway_types::BucketName;
#[test]
#[serial_test::serial]
fn list_apis_report_storage_read_quorum_as_unavailable() {
use crate::app::bucket_usecase::test_support::owned_envelope;
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient, shared_gating_ecstore};
run_large_stack_test("list-quorum-surface", || async {
let usecase = DefaultBucketUsecase::with_context(Some(shared_gating_ambient().await));
@@ -485,7 +484,7 @@ mod tests {
}
fn envelope() -> RequestEnvelope {
RequestEnvelope::from_s3s(&build_request((), http::Method::GET))
owned_envelope(http::Method::GET)
}
#[test]
+2 -4
View File
@@ -56,7 +56,7 @@ impl DefaultBucketUsecase {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
use crate::app::bucket_usecase::{BucketOperations, DeleteBucketOptions, MakeBucketOptions};
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
use crate::app::runtime_sources::ServerContextSlot;
@@ -75,10 +75,8 @@ mod tests {
let context = shared_gating_ambient().await;
let bucket = format!("logging-missing-{}", uuid::Uuid::new_v4().simple());
let usecase = DefaultBucketUsecase::with_context(Some(context));
let request = build_request((), Method::PUT);
let envelope = RequestEnvelope::from_s3s(&request);
let error = usecase
.execute_put_bucket_logging(envelope, &bucket, || {
.execute_put_bucket_logging(owned_envelope(Method::PUT), &bucket, || {
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid logging configuration"))
})
.await
+4 -7
View File
@@ -243,16 +243,15 @@ impl DefaultBucketUsecase {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::owned_envelope;
use http::Method;
#[tokio::test]
async fn execute_delete_bucket_policy_returns_internal_error_when_store_uninitialized() {
let req = build_request((), Method::DELETE);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_delete_bucket_policy(RequestEnvelope::from_s3s(&req), "test-bucket")
.execute_delete_bucket_policy(owned_envelope(Method::DELETE), "test-bucket")
.await
.unwrap_err();
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
@@ -280,11 +279,10 @@ mod tests {
bucket: bucket("test-bucket"),
..Default::default()
};
let req = build_request((), Method::GET);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_get_bucket_policy_status(RequestEnvelope::from_s3s(&req), input)
.execute_get_bucket_policy_status(owned_envelope(Method::GET), input)
.await
.unwrap_err();
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
@@ -292,11 +290,10 @@ mod tests {
#[tokio::test]
async fn execute_put_bucket_policy_returns_internal_error_when_store_uninitialized() {
let req = build_request((), Method::PUT);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_put_bucket_policy(RequestEnvelope::from_s3s(&req), "test-bucket", "{}")
.execute_put_bucket_policy(owned_envelope(Method::PUT), "test-bucket", "{}")
.await
.unwrap_err();
assert_eq!(err.code(), &rustfs_s3_types::S3ErrorCode::InternalError);
@@ -112,7 +112,7 @@ impl DefaultBucketUsecase {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
use crate::app::runtime_sources::ServerContextSlot;
use crate::app::storage_api::bucket_usecase::helper::MutationCompletionProbe;
@@ -278,7 +278,7 @@ mod tests {
#[tokio::test]
async fn execute_delete_public_access_block_returns_internal_error_when_store_uninitialized() {
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::DELETE));
let envelope = owned_envelope(Method::DELETE);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_delete_public_access_block(envelope, "test-bucket")
@@ -296,7 +296,7 @@ mod tests {
#[tokio::test]
async fn execute_put_public_access_block_returns_internal_error_when_store_uninitialized() {
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
let envelope = owned_envelope(Method::PUT);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_put_public_access_block(envelope, "test-bucket", Ok(PersistedPublicAccessBlockConfiguration::default()))
+3 -4
View File
@@ -138,7 +138,7 @@ impl DefaultBucketUsecase {
#[cfg(test)]
mod tests {
use super::*;
use crate::app::bucket_usecase::test_support::build_request;
use crate::app::bucket_usecase::test_support::{build_request, owned_envelope};
use crate::app::storage_api::s3::dto::{self, PutBucketTaggingInput, Tag, Tagging};
use http::Method;
use rustfs_s3_types::S3ErrorCode;
@@ -249,11 +249,10 @@ mod tests {
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let usecase = DefaultBucketUsecase::without_context();
let err = usecase
.execute_put_bucket_tagging(RequestEnvelope::from_s3s(&req), &req.input.bucket, PersistedTagging::default())
.execute_put_bucket_tagging(owned_envelope(Method::PUT), &input.bucket, PersistedTagging::default())
.await
.unwrap_err();
assert_eq!(err.code(), &S3ErrorCode::InternalError);
@@ -267,7 +266,7 @@ mod tests {
(vec![tag; MAX_BUCKET_TAGS + 1], "Cannot have more than 50 tags per bucket"),
] {
let err = usecase
.execute_put_bucket_tagging(RequestEnvelope::from_s3s(&req), &req.input.bucket, PersistedTagging { tag_set })
.execute_put_bucket_tagging(owned_envelope(Method::PUT), &input.bucket, PersistedTagging { tag_set })
.await
.unwrap_err();
assert_eq!(err.code(), &S3ErrorCode::InvalidTag);
+11 -1
View File
@@ -47,7 +47,17 @@ pub(super) fn gateway_bucket(name: &str) -> rustfs_gateway_types::BucketName {
/// The envelope of a request that carries nothing but `method`.
pub(super) fn owned_envelope(method: Method) -> RequestEnvelope {
RequestEnvelope::from_s3s(&build_request((), method))
RequestEnvelope::from_parts(
crate::app::RequestHead {
method,
uri: Uri::from_static("/"),
headers: HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
Extensions::new(),
)
}
pub(super) fn build_request_with_req_info<T>(input: T, method: Method, req_info: ReqInfo) -> S3Request<T> {
+4 -5
View File
@@ -81,7 +81,7 @@ impl DefaultBucketUsecase {
mod tests {
use super::super::{BUCKET_ACCELERATE_CONFIG, BUCKET_REQUEST_PAYMENT_CONFIG};
use super::*;
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info};
use crate::app::bucket_usecase::test_support::{build_request, build_request_with_req_info, owned_envelope};
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient};
use crate::app::runtime_sources::ServerContextSlot;
use crate::app::storage_api::object_usecase::helper::MutationCompletionProbe;
@@ -190,22 +190,21 @@ mod tests {
let ambient = shared_gating_ambient().await;
let usecase = DefaultBucketUsecase::with_context(Some(ambient));
let bucket = format!("core-config-missing-{}", uuid::Uuid::new_v4().simple());
let request = build_request((), http::Method::PUT);
let mut converted = [false; 3];
let accelerate = usecase
.execute_put_bucket_accelerate_configuration(RequestEnvelope::from_s3s(&request), &bucket, || {
.execute_put_bucket_accelerate_configuration(owned_envelope(http::Method::PUT), &bucket, || {
converted[0] = true;
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid acceleration"))
})
.await;
let payment = usecase
.execute_put_bucket_request_payment(RequestEnvelope::from_s3s(&request), &bucket, || {
.execute_put_bucket_request_payment(owned_envelope(http::Method::PUT), &bucket, || {
converted[1] = true;
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid request payment"))
})
.await;
let website = usecase
.execute_put_bucket_website(RequestEnvelope::from_s3s(&request), &bucket, || {
.execute_put_bucket_website(owned_envelope(http::Method::PUT), &bucket, || {
converted[2] = true;
Err(rustfs_s3_types::s3_error!(MalformedXML, "invalid website"))
})
@@ -52,8 +52,19 @@ async fn object_lock_handlers_schedule_replication() {
.expect("Failed to create object-lock bucket");
upload_test_object(&ecstore, bucket.as_str(), object, b"worm payload").await;
let req = build_request((), Method::PUT);
let envelope = || RequestEnvelope::from_s3s(&req);
let envelope = || {
RequestEnvelope::from_parts(
crate::app::RequestHead {
method: Method::PUT,
uri: Uri::from_static("/"),
headers: HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
Extensions::new(),
)
};
// A bucket without a replication configuration can skip the decision.
MUST_REPLICATE_OBJECT_CALLS.store(0, Ordering::SeqCst);
@@ -22,7 +22,17 @@ const RESTORE_SUSPENDED_WAIT_TIMEOUT: Duration = Duration::from_secs(15);
async fn suspend_test_bucket(bucket: &str) {
DefaultBucketUsecase::from_global()
.execute_put_bucket_versioning(
crate::app::RequestEnvelope::from_s3s(&build_request((), Method::PUT)),
crate::app::RequestEnvelope::from_parts(
crate::app::RequestHead {
method: Method::PUT,
uri: Uri::from_static("/"),
headers: HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
Extensions::new(),
),
bucket,
Ok(rustfs_gateway_types::persistence::PersistedVersioningConfiguration {
status: Some("Suspended".to_owned()),
+19 -6
View File
@@ -545,10 +545,17 @@ mod tests {
.key(key.to_owned())
.build()
.expect("valid create request DTO");
let error = make_usecase()
.execute_create_multipart_upload_from_s3s(build_request(create, Method::POST))
let error = match make_usecase()
.execute_create_multipart_upload(
owned_envelope(Method::POST),
super::create_values::CreateMultipartUploadFields::from_legacy(create),
None,
)
.await
.expect_err("reserved key must be rejected before accessing storage");
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("reserved key must be rejected before accessing storage"),
};
assert_eq!(error.code(), &crate::app::storage_api::s3::S3ErrorCode::InvalidArgument);
let complete = CompleteMultipartUploadInput::builder()
@@ -558,9 +565,15 @@ mod tests {
.multipart_upload(Some(CompletedMultipartUpload::default()))
.build()
.expect("valid complete request DTO");
let error = Box::pin(make_usecase().complete_for_s3s_request(build_request(complete, Method::POST)))
.await
.expect_err("uploads created before the fix must not publish reserved keys");
let error =
match rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload::input_from_s3s(
complete,
) {
Err(error) => crate::app::dto_values::seam_error(error),
Ok(input) => Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), input))
.await
.expect_err("uploads created before the fix must not publish reserved keys"),
};
assert_eq!(error.code(), &rustfs_s3_types::S3ErrorCode::InvalidArgument);
}
}
@@ -24,8 +24,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
#[tokio::test]
async fn execute_abort_multipart_upload_returns_internal_error_when_store_uninitialized() {
let request = build_request((), Method::DELETE);
let envelope = RequestEnvelope::from_s3s(&request);
let envelope = owned_envelope(Method::DELETE);
let before = s3_op_total(S3Operation::AbortMultipartUpload);
let target = AbortMultipartUploadTarget::Legacy {
bucket: "bucket".to_owned(),
+233 -38
View File
@@ -943,21 +943,72 @@ mod tests {
#[tokio::test]
async fn execute_complete_multipart_upload_rejects_missing_parts_payload() {
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let input = CompleteMultipartUploadInput::builder()
.bucket("bucket".to_string())
.key("object".to_string())
.upload_id("upload-id".to_string())
.build()
.unwrap();
let req = build_request(input, Method::POST);
let err = Box::pin(make_usecase().complete_for_s3s_request(req)).await.unwrap_err();
let mut s3s_input = input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => crate::app::dto_values::seam_error(error),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
let result = match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
};
result.unwrap_err()
}
};
assert_eq!(err.code(), &S3ErrorCode::InvalidPart);
}
#[tokio::test]
async fn execute_complete_multipart_upload_rejects_missing_parts_list() {
use crate::app::storage_api::s3::xml::Deserialize as _;
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let mut deserializer = crate::app::storage_api::s3::xml::Deserializer::new(b"<CompleteMultipartUpload/>");
let multipart_upload =
@@ -974,11 +1025,57 @@ mod tests {
.multipart_upload(Some(multipart_upload))
.build()
.expect("complete multipart input should build");
let req = build_request(input, Method::POST);
let err = Box::pin(make_usecase().complete_for_s3s_request(req))
.await
.expect_err("missing parts list must be rejected");
let mut s3s_input = input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => crate::app::dto_values::seam_error(error),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
let result = match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
};
result.expect_err("missing parts list must be rejected")
}
};
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
}
@@ -1124,10 +1221,9 @@ mod tests {
crate::app::gating_test_env::run_large_stack_test("ssec-completion-checksums", || async {
let (_store, bucket) =
crate::app::gating_test_env::durable_quota_test_bucket("ssec-completion-checksums", 16_384).await;
let versioning_req = build_request((), Method::PUT);
crate::app::bucket_usecase::DefaultBucketUsecase::from_global()
.execute_put_bucket_versioning(
RequestEnvelope::from_s3s(&versioning_req),
super::super::test_support::owned_envelope(Method::PUT),
&bucket,
Ok(rustfs_gateway_types::persistence::PersistedVersioningConfiguration {
status: Some("Enabled".to_owned()),
@@ -1304,16 +1400,13 @@ mod tests {
let bucket_usecase = crate::app::bucket_usecase::DefaultBucketUsecase::from_global();
// Listings carry neither the SSE-C key nor a per-object decryption request.
let versions_req = build_request(
ListObjectVersionsInput {
bucket: bucket.to_string(),
prefix: Some(key.to_string()),
..Default::default()
},
Method::GET,
);
let versions_env = RequestEnvelope::from_s3s(&versions_req);
let versions_in = list_object_versions::input_from_s3s(versions_req.input).expect("convert ListObjectVersionsInput");
let versions_input = ListObjectVersionsInput {
bucket: bucket.to_string(),
prefix: Some(key.to_string()),
..Default::default()
};
let versions_env = super::super::test_support::owned_envelope(Method::GET);
let versions_in = list_object_versions::input_from_s3s(versions_input).expect("convert ListObjectVersionsInput");
let versions = list_object_versions::output_to_s3s(
bucket_usecase
.execute_list_object_versions(versions_env, versions_in)
@@ -1328,16 +1421,13 @@ mod tests {
assert_eq!(entries[0].e_tag.as_ref(), Some(etag));
assert_xml_etag(&versions, etag);
let v1_req = build_request(
ListObjectsInput {
bucket: bucket.to_string(),
prefix: Some(key.to_string()),
..Default::default()
},
Method::GET,
);
let v1_env = RequestEnvelope::from_s3s(&v1_req);
let v1_in = list_objects::input_from_s3s(v1_req.input).expect("convert ListObjectsInput");
let v1_input = ListObjectsInput {
bucket: bucket.to_string(),
prefix: Some(key.to_string()),
..Default::default()
};
let v1_env = super::super::test_support::owned_envelope(Method::GET);
let v1_in = list_objects::input_from_s3s(v1_input).expect("convert ListObjectsInput");
let v1 = list_objects::output_to_s3s(
bucket_usecase
.execute_list_objects(v1_env, v1_in)
@@ -1411,7 +1501,6 @@ mod tests {
.await
.expect("create versioned Object Lock bucket");
let key = "kms-encrypted";
let enc_req = build_request((), Method::PUT);
let enc_cfg = crate::app::storage_api::s3::dto::ServerSideEncryptionConfiguration {
rules: vec![crate::app::storage_api::s3::dto::ServerSideEncryptionRule {
apply_server_side_encryption_by_default: Some(
@@ -1425,7 +1514,7 @@ mod tests {
};
let prepared = crate::storage::persisted_from_s3s(&enc_cfg).map_err(Into::into);
crate::app::bucket_usecase::DefaultBucketUsecase::from_global()
.execute_put_bucket_encryption(RequestEnvelope::from_s3s(&enc_req), &bucket, prepared)
.execute_put_bucket_encryption(super::super::test_support::owned_envelope(Method::PUT), &bucket, prepared)
.await
.expect("configure bucket-default SSE-KMS");
let usecase = DefaultMultipartUsecase::from_global();
@@ -2151,6 +2240,8 @@ mod tests {
#[tokio::test]
async fn execute_complete_multipart_upload_allows_duplicate_part_numbers_by_using_last_occurrence() {
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let multipart_upload = CompletedMultipartUpload {
parts: Some(vec![
CompletedPart {
@@ -2170,14 +2261,67 @@ mod tests {
.multipart_upload(Some(multipart_upload))
.build()
.unwrap();
let req = build_request(input, Method::POST);
let err = Box::pin(make_usecase().complete_for_s3s_request(req)).await.unwrap_err();
let mut s3s_input = input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => crate::app::dto_values::seam_error(error),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
let result = match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
};
match result {
Err(error) => error,
Ok(_output) => panic!("duplicate part numbers must not succeed before the order check"),
}
}
};
assert_ne!(err.code(), &S3ErrorCode::InvalidPartOrder);
}
#[tokio::test]
async fn execute_complete_multipart_upload_rejects_out_of_order_parts() {
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let multipart_upload = CompletedMultipartUpload {
parts: Some(vec![
CompletedPart {
@@ -2197,9 +2341,60 @@ mod tests {
.multipart_upload(Some(multipart_upload))
.build()
.unwrap();
let req = build_request(input, Method::POST);
let err = Box::pin(make_usecase().complete_for_s3s_request(req)).await.unwrap_err();
let mut s3s_input = input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let err = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => crate::app::dto_values::seam_error(error),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
let result = match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(make_usecase().execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(make_usecase().execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
};
match result {
Err(error) => error,
Ok(_output) => panic!("out-of-order parts must be rejected"),
}
}
};
assert_eq!(err.code(), &S3ErrorCode::InvalidPartOrder);
}
+16 -8
View File
@@ -545,10 +545,17 @@ mod tests {
.object_lock_retain_until_date(date.map(Timestamp::from))
.build()
.expect("direct fixture DTO");
let error = make_usecase()
.execute_create_multipart_upload_from_s3s(build_request(input, Method::POST))
let error = match make_usecase()
.execute_create_multipart_upload(
owned_envelope(Method::POST),
CreateMultipartUploadFields::from_legacy(input),
None,
)
.await
.expect_err("direct fixture does not create an upload");
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("direct fixture does not create an upload"),
};
assert_eq!(
(error.code().as_str(), error.message()),
(expected.0, Some(expected.1)),
@@ -590,12 +597,13 @@ mod tests {
.storage_class(Some(StorageClass::from("invalid".to_string())))
.build()
.unwrap();
let req = build_request(input, Method::POST);
let err = make_usecase()
.execute_create_multipart_upload_from_s3s(req)
let err = match make_usecase()
.execute_create_multipart_upload(owned_envelope(Method::POST), CreateMultipartUploadFields::from_legacy(input), None)
.await
.unwrap_err();
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("invalid storage class must be rejected"),
};
assert_eq!(err.code(), &S3ErrorCode::InvalidStorageClass);
}
+2 -2
View File
@@ -295,7 +295,7 @@ mod tests {
async fn list_uploads(input: gateway_dto::ListMultipartUploadsInput) -> rustfs_s3_types::S3Error {
make_usecase()
.execute_list_multipart_uploads(RequestEnvelope::from_s3s(&build_request((), Method::GET)), input)
.execute_list_multipart_uploads(owned_envelope(Method::GET), input)
.await
.expect_err("refused")
}
@@ -393,7 +393,7 @@ mod tests {
max_parts,
};
make_usecase()
.execute_list_parts(RequestEnvelope::from_s3s(&build_request((), Method::GET)), fields)
.execute_list_parts(owned_envelope(Method::GET), fields)
.await
.expect_err("refused")
}
@@ -14,7 +14,7 @@
//! ListParts execution against real multipart metadata and the native claim exchange.
use super::super::test_support::{Method, build_request};
use super::super::test_support::{Method, build_request, owned_envelope};
use super::*;
use crate::app::gating_test_env::{run_large_stack_test, shared_gating_ambient, shared_gating_ecstore_and_disk_paths};
use crate::app::storage_api::multipart_usecase::access::{AuthorizationRequest, load_bucket_generation_from_store};
@@ -81,7 +81,7 @@ fn list_parts_resolves_real_owners_and_retains_storage_errors() {
let key = "fixture/one";
let foreign_key = "fixture/two";
let opts = ObjectOptions::default();
let envelope = || RequestEnvelope::from_s3s(&build_request((), Method::GET));
let envelope = || owned_envelope(Method::GET);
for name in [&bucket, &foreign_bucket] {
store
.make_bucket(name, &MakeBucketOptions::default())
@@ -18,6 +18,7 @@ use super::*;
use crate::app::storage_api::s3::S3Request;
pub(super) use crate::app::storage_api::s3::dto::CompletedMultipartUpload;
pub(super) use crate::app::storage_api::s3::dto::StorageClass;
use crate::app::{RequestEnvelope, RequestHead};
pub(super) use http::Extensions;
pub(super) use http::Method;
pub(super) use rustfs_filemeta::ObjectPartInfo;
@@ -50,6 +51,21 @@ pub(super) fn build_request<T>(input: T, method: Method) -> S3Request<T> {
}
}
/// The envelope of a request that carries nothing but `method`.
pub(super) fn owned_envelope(method: Method) -> RequestEnvelope {
RequestEnvelope::from_parts(
RequestHead {
method,
uri: Uri::from_static("/"),
headers: HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
Extensions::new(),
)
}
pub(super) fn make_usecase() -> DefaultMultipartUsecase {
DefaultMultipartUsecase::without_context()
}
+27 -12
View File
@@ -741,9 +741,13 @@ mod tests {
.part_number(1)
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
let err = match make_usecase()
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
.await
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("missing body must be rejected"),
};
assert_eq!(err.code(), &LegacyErrorCode::IncompleteBody);
}
@@ -765,9 +769,13 @@ mod tests {
.content_length(Some(declared))
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
let err = match make_usecase()
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
.await
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("declared part must be rejected"),
};
if expect_too_large {
assert_eq!(err.code(), &LegacyErrorCode::EntityTooLarge, "declared {declared}");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 0, "body must not be polled");
@@ -787,9 +795,13 @@ mod tests {
.part_number(part_number)
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let err = make_usecase().execute_upload_part(req).await.unwrap_err();
let err = match make_usecase()
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
.await
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("invalid part number must be rejected"),
};
assert_eq!(err.code(), &LegacyErrorCode::InvalidArgument);
assert_eq!(err.message(), Some("partNumber must be between 1 and 10000"));
}
@@ -971,10 +983,13 @@ mod tests {
.build()
.expect("upload part input should build");
let err = usecase
.execute_upload_part(build_request(input, Method::PUT))
let err = match usecase
.execute_upload_part_with_audit(owned_envelope(Method::PUT), UploadPartWriteInput::from_legacy(input, None))
.await
.expect_err("full foreground write admission should reject before body ingest");
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("full foreground write admission should reject before body ingest"),
};
assert_eq!(err.code(), &LegacyErrorCode::SlowDown);
drop(held);
}
@@ -14,6 +14,7 @@
//! Upload target ownership and refusal order against real multipart state.
use super::super::super::test_support::owned_envelope;
use super::*;
use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, MakeBucketOptions};
use rustfs_gateway_types::{BucketName, ObjectKey, UploadIdClaim};
@@ -101,7 +102,7 @@ async fn native_claim_checks_order_ownership_and_one_active_lookup() {
Body::from(Bytes::from_static(b"abc"))
}
});
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
let envelope = owned_envelope(Method::PUT);
LOOKUP
.scope((Cell::new(0), mode), async {
let result = usecase.execute_upload_part_with_audit(envelope, input).await;
@@ -211,7 +212,7 @@ fn native_copy_part_rejects_unproved_owner_without_changing_parts() {
copy_source_sse_customer_key: None,
copy_source_sse_customer_key_md5: None,
};
let envelope = RequestEnvelope::from_s3s(&build_request((), Method::PUT));
let envelope = owned_envelope(Method::PUT);
LOOKUP
.scope((Cell::new(0), mode), async {
let result = Box::pin(usecase.execute_upload_part_copy_with_audit(envelope, input)).await;
@@ -561,6 +561,9 @@ impl DefaultMultipartUsecase {
mod tests {
use super::super::test_support::*;
use super::*;
use crate::app::multipart_usecase::UploadPartTarget;
use crate::app::object_usecase::CopySourceCondition;
use crate::app::storage_api::s3::dto::ETag;
#[tokio::test]
async fn execute_upload_part_copy_returns_internal_error_when_store_uninitialized() {
@@ -576,9 +579,37 @@ mod tests {
.upload_id("upload-id".to_string())
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let err = Box::pin(make_usecase().execute_upload_part_copy(req)).await.unwrap_err();
let condition = |value| match value {
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
};
let err = match Box::pin(make_usecase().execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: input.bucket,
key: input.key,
upload_id: input.upload_id,
},
part_number: input.part_number,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
copy_source_range: input.copy_source_range,
copy_source_if_match: input.copy_source_if_match.map(&condition),
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
sse_customer_algorithm: input.sse_customer_algorithm,
sse_customer_key: input.sse_customer_key,
sse_customer_key_md5: input.sse_customer_key_md5,
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
},
))
.await
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("uninitialized store must be an internal error"),
};
assert_eq!(err.code(), &crate::app::storage_api::s3::S3ErrorCode::InternalError);
}
@@ -597,9 +628,37 @@ mod tests {
.upload_id("upload-id".to_string())
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let err = Box::pin(make_usecase().execute_upload_part_copy(req)).await.unwrap_err();
let condition = |value| match value {
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
};
let err = match Box::pin(make_usecase().execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: input.bucket,
key: input.key,
upload_id: input.upload_id,
},
part_number: input.part_number,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
copy_source_range: input.copy_source_range,
copy_source_if_match: input.copy_source_if_match.map(&condition),
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
sse_customer_algorithm: input.sse_customer_algorithm,
sse_customer_key: input.sse_customer_key,
sse_customer_key_md5: input.sse_customer_key_md5,
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
},
))
.await
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("invalid part number must be rejected"),
};
assert_eq!(err.code(), &crate::app::storage_api::s3::S3ErrorCode::InvalidArgument);
assert_eq!(err.message(), Some("partNumber must be between 1 and 10000"));
}
@@ -76,9 +76,38 @@ fn upload_part_copy_shares_foreground_admission_with_upload_part() {
.any(|label| label.key() == "size_bucket" && label.value() == source_size_bucket)
})
};
let error = Box::pin(usecase.execute_upload_part_copy(build_request(input.clone(), Method::PUT)))
.await
.expect_err("copy must not bypass the occupied UploadPart pool");
let saturated = input.clone();
let condition = |value| match value {
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
};
let error = match Box::pin(usecase.execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: saturated.bucket,
key: saturated.key,
upload_id: saturated.upload_id,
},
part_number: saturated.part_number,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(saturated.copy_source),
copy_source_range: saturated.copy_source_range,
copy_source_if_match: saturated.copy_source_if_match.map(&condition),
copy_source_if_none_match: saturated.copy_source_if_none_match.map(&condition),
sse_customer_algorithm: saturated.sse_customer_algorithm,
sse_customer_key: saturated.sse_customer_key,
sse_customer_key_md5: saturated.sse_customer_key_md5,
copy_source_sse_customer_algorithm: saturated.copy_source_sse_customer_algorithm,
copy_source_sse_customer_key: saturated.copy_source_sse_customer_key,
copy_source_sse_customer_key_md5: saturated.copy_source_sse_customer_key_md5,
},
))
.await
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("copy must not bypass the occupied UploadPart pool"),
};
assert_eq!(error.code(), &S3ErrorCode::SlowDown);
assert!(!source_reader_observed(), "saturated copy must not construct a source body reader");
let parts = store
@@ -165,9 +194,37 @@ fn upload_part_copy_shares_foreground_admission_with_upload_part() {
.upload_id(deleted_upload.upload_id.clone())
.build()
.expect("deleted-source copy request");
let error = Box::pin(usecase.execute_upload_part_copy(build_request(input, Method::PUT)))
.await
.expect_err("deleted source must fail before conditions or admission");
let condition = |value| match value {
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
};
let error = match Box::pin(usecase.execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: input.bucket,
key: input.key,
upload_id: input.upload_id,
},
part_number: input.part_number,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
copy_source_range: input.copy_source_range,
copy_source_if_match: input.copy_source_if_match.map(&condition),
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
sse_customer_algorithm: input.sse_customer_algorithm,
sse_customer_key: input.sse_customer_key,
sse_customer_key_md5: input.sse_customer_key_md5,
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
},
))
.await
{
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("deleted source must fail before conditions or admission"),
};
assert_eq!(error.code(), &expected);
}
});
@@ -211,7 +268,32 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
.upload_id(cancelled_upload.upload_id.clone())
.build()
.expect("cancelled copy request");
let mut cancelled_copy = Box::pin(usecase.execute_upload_part_copy(build_request(cancelled_input, Method::PUT)));
let condition = |value| match value {
crate::app::storage_api::s3::dto::ETagCondition::Any => CopySourceCondition::Any,
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Strong(value)) => CopySourceCondition::Strong(value),
crate::app::storage_api::s3::dto::ETagCondition::ETag(ETag::Weak(_)) => CopySourceCondition::Weak,
};
let mut cancelled_copy = Box::pin(usecase.execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: cancelled_input.bucket,
key: cancelled_input.key,
upload_id: cancelled_input.upload_id,
},
part_number: cancelled_input.part_number,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(cancelled_input.copy_source),
copy_source_range: cancelled_input.copy_source_range,
copy_source_if_match: cancelled_input.copy_source_if_match.map(&condition),
copy_source_if_none_match: cancelled_input.copy_source_if_none_match.map(&condition),
sse_customer_algorithm: cancelled_input.sse_customer_algorithm,
sse_customer_key: cancelled_input.sse_customer_key,
sse_customer_key_md5: cancelled_input.sse_customer_key_md5,
copy_source_sse_customer_algorithm: cancelled_input.copy_source_sse_customer_algorithm,
copy_source_sse_customer_key: cancelled_input.copy_source_sse_customer_key,
copy_source_sse_customer_key_md5: cancelled_input.copy_source_sse_customer_key_md5,
},
));
tokio::time::timeout(Duration::from_secs(10), async {
tokio::select! {
biased;
@@ -220,7 +302,10 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
tokio::task::yield_now().await;
}
} => {}
result = &mut cancelled_copy => panic!("copy completed before cancellation: {result:?}"),
result = &mut cancelled_copy => match result {
Ok(_) => panic!("copy completed before cancellation"),
Err(error) => panic!("copy completed before cancellation: {error:?}"),
},
}
})
.await
@@ -260,17 +345,39 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
.upload_id(upload.upload_id.clone())
.build()
.expect("range request");
let response = Box::pin(usecase.execute_upload_part_copy(build_request(input, Method::PUT))).await;
let response = Box::pin(usecase.execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: input.bucket,
key: input.key,
upload_id: input.upload_id,
},
part_number: input.part_number,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
copy_source_range: input.copy_source_range,
copy_source_if_match: input.copy_source_if_match.map(&condition),
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
sse_customer_algorithm: input.sse_customer_algorithm,
sse_customer_key: input.sse_customer_key,
sse_customer_key_md5: input.sse_customer_key_md5,
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
},
))
.await;
assert_eq!(
manager.put_object_admission_snapshot().active,
Some(0),
"copy releases its permit on every outcome"
);
if capped {
assert_eq!(
response.expect_err("range exceeds destination size limit").code(),
&S3ErrorCode::EntityTooLarge
);
let error = match response {
Err(error) => crate::app::storage_api::s3::S3Error::from(error),
Ok(_) => panic!("range exceeds destination size limit"),
};
assert_eq!(error.code(), &S3ErrorCode::EntityTooLarge);
let parts = store
.list_object_parts(&bucket, "object", &upload.upload_id, None, 1000, &ObjectOptions::default())
.await
@@ -281,16 +388,16 @@ fn upload_part_copy_range_error_and_cancellation_release_foreground_permit() {
.await
.expect("abort capped session");
} else {
let copied = response.expect("range copy after failed request released its source and permit");
let copied = match response {
Ok(output) => output,
Err(error) => panic!("range copy after failed request released its source and permit: {error:?}"),
};
let etag = copied
.output
.copy_part_result
.expect("range result")
.e_tag
.expect("range ETag")
.value()
.trim_matches('"')
.to_owned();
.as_deref()
.map(crate::storage::storage_api::to_s3s_xml_etag)
.expect("range ETag");
let etag = etag.value().trim_matches('"').to_owned();
Arc::clone(&store)
.complete_multipart_upload(
&bucket,
+11 -2
View File
@@ -258,8 +258,17 @@ mod tests {
sse_customer_key: None,
sse_customer_key_md5: None,
};
let request = build_request((), http::Method::GET);
let envelope = RequestEnvelope::from_s3s(&request);
let envelope = RequestEnvelope::from_parts(
crate::app::RequestHead {
method: http::Method::GET,
uri: http::Uri::from_static("/"),
headers: http::HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
http::Extensions::new(),
);
let error = DefaultObjectUsecase::without_context()
.execute_get_object_attributes(envelope, fields)
.await
@@ -1,22 +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.
//! Authorization shapes that only migration batch A2 (rustfs/backlog#2765) uses: bucket policy, policy status, versioning, notification and ACL.
//!
//! Responsible for: the owned authorization function of each such operation, generic over
//! `AuthorizationRequest`, so the legacy `S3Access` hook and `Served::authorize` call the same code.
//! Not responsible for: shapes more than one batch shares (those stay in `storage/access.rs`), the
//! policy evaluation itself (`authorize_request`), or the operation's use case.
//! Upstream: the legacy hook in `storage/access.rs` and the batch's `server/gateway_handlers/bucket_access.rs`.
//! Downstream: the shared shapes in `storage/access.rs`.
@@ -1,22 +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.
//! Authorization shapes that only migration batch A1 (rustfs/backlog#2765) uses: bucket CORS, tagging, public access block and encryption.
//!
//! Responsible for: the owned authorization function of each such operation, generic over
//! `AuthorizationRequest`, so the legacy `S3Access` hook and `Served::authorize` call the same code.
//! Not responsible for: shapes more than one batch shares (those stay in `storage/access.rs`), the
//! policy evaluation itself (`authorize_request`), or the operation's use case.
//! Upstream: the legacy hook in `storage/access.rs` and the batch's `server/gateway_handlers/bucket_configs.rs`.
//! Downstream: the shared shapes in `storage/access.rs`.
-2
View File
@@ -15,8 +15,6 @@
//! The authorization shapes one migration batch owns (rustfs/backlog#2765), one file per batch so
//! parallel batches edit disjoint files. Shapes several batches share stay in `storage/access.rs`.
pub(crate) mod bucket_access;
pub(crate) mod bucket_configs;
pub(crate) mod bucket_core;
pub(crate) mod bucket_replication_lifecycle;
pub(crate) mod listing_multipart;