Compare commits

..

102 Commits

Author SHA1 Message Date
Hauser Zhi 739699426b fix(rpc): scope canary errors to grpc failures
Exclude expected read-version remote responses without hiding transport, gRPC status, response-decode, or other gRPC operation failures.

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

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 23:02:29 +08:00
Hauser Zhi 0d2a0ea345 test(rpc): orchestrate msgpack peer canary
Run the fixed mixed/all-new/rollback four-node matrix with prebuilt images, real workload and readback, raw Prometheus capture, strict manifest generation, and adversarial fake integration tests.

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

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 14:26:53 +08:00
Hauser Zhi c1f97d27f6 test(rpc): align batch read manifest encoder
Match the BatchReadVersion compatibility manifest to the request-owned encoder expression used by the production send path.

Restore the owning ECStore source guard while preserving wire and runtime behavior.

Co-Authored-By: heihutu <heihutu@gmail.com>
Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 13:58:28 +08:00
Hauser Zhi 1066ab4d1d Merge branch 'main' into feat/grpc-predispatch-generation-guard 2026-11-15 13:43:00 +08:00
Hauser Zhi b0e824437b test(rpc): verify msgpack peer canary evidence
Add a strict three-phase four-node evidence verifier with raw Prometheus and workload receipts, adversarial tests, script-test wiring, and the operational manifest contract.

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

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 13:42:08 +08:00
overtrue 77da63397c feat(s3): serve PutBucketLifecycleConfiguration through the gateway
Validate lifecycle status across both request adapters and preserve mutation error priority, ordered rule IDs, and stored dates. Forward the original bucket and request envelope at the legacy edge. Pin the gateway lifecycle date carrier.

The priority fixture covers seven refusal cases and one success case. All 39 scoped tests passed after source restoration. Fifteen fault switches triggered 16 expected failures covering priority, early conversion, metrics and audit, action binding, transition writes, date precision, offsets, and rule indices.

The tests and both Clippy modes passed on 0567078 with gateway 2a6b8d1. The gateway all-target check and prepush passed after rebasing onto 1467d32. Full-workspace and remote CI results remain unverified.
2026-11-15 13:08:53 +08:00
Hauser Zhi 913a5df515 Merge branch 'main' into feat/grpc-predispatch-generation-guard 2026-11-15 12:40:17 +08:00
Hauser Zhi f483cfedc8 feat(rpc): apply per-peer msgpack send policy
Capture one capability decision per eligible RPC, bind peer-mode requests to boot and connection generations, and rebuild at most one dual-write request only after a locally proven pre-dispatch rejection.

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

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 12:39:59 +08:00
Hauser Zhi f2177505da feat(rpc): add per-peer msgpack rollout gate
Add the default-off peer-capability environment gate, cached evaluation, fixed-cardinality send-decision metrics, and rollout constraints for stable peer-affine connections.

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

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 12:39:59 +08:00
overtrue 1467d32695 feat(gateway): serve PutObject through the owned write path
Register PutObject and share write authorization with legacy PUT and
browser POST. Carry authenticated trailer declarations and captured
frames into the owned write, preserve typed eager-read errors, and keep
the table-catalog guard tied to the actual write call.

Verified on RustFS 0567078f5 with gateway d75b6ce on macOS. All 1022
affected tests passed with a 4 MiB test stack, along with both
all-target Clippy configurations, script tests, test wiring, and
prepush checks. A separate gateway wire run stored and read an empty
object using the rebuilt server binary.

Fourteen single-fault checks covered trailer selection and capture,
typed producer failures, tag policies, the shared write grants, and
POST policy projection. The reserved-prefix source guard also rejected
a fixture whose owned write call was replaced.
2026-11-15 11:51:26 +08:00
overtrue 2c2af51a46 feat(gateway): serve PutBucketVersioning
Route bucket versioning writes through the shared authorization and audited use case. Preserve legacy configuration preparation, the incarnation fence, refusal order, persisted XML, and the reload, replication, and scanner callbacks. Count each admitted write once at its edge.

Verified against RustFS 0567078f5 and gateway d75b6ceb. The signed wire cases cover six accepted writes and nine refusals per stack. The affected suite passed 29 tests, the typed-error suite passed 26, and both Clippy configurations, script tests, wiring, and prepush checks passed. The wire cases and both refusal matrices passed again after boxing the test fixture's SDK error.

Eight fault controls went red for both authorization hooks, the legacy counter, an omitted write, a dropped empty excluded prefix, Object Lock precedence, replication refusal, and the custom-status error. CI, the Linux reference comparison, and live multi-node callback delivery remain unverified.
2026-11-15 11:33:25 +08:00
Hauser Zhi a758b58bf2 feat(rpc): guard stale generations before dispatch
Reject generation-bound requests before inner transport call or first payload frame when tonic readiness observes a different physical connection, while leaving ordinary mutations unguarded until the send-policy follow-up.

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

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 09:57:58 +08:00
overtrue 0567078f5b feat(gateway): serve GetObject through the owned read path
Register GetObject and share its authorization and native response facts
with the legacy edge. Preserve conditional headers, range completion,
stream errors, body ownership, SSE reads and request accounting. Pin the
gateway 304 response-override fix without unrelated dependency changes.
Keep the incoming native Put path and update its profiling guard source.

Validation on b7e7a6156:
- Normal and mutation-disabled controls: 9/9 each.
- Affected suite: 754/755; the profiling guard still read the old Put file.
  After correcting that source path, its targeted rerun passed 1/1.
- All-target Clippy passed with gateway-stack and default features.
- Formatting, script-tests, test wiring and prepush-quick passed.
- Authorization matrix: 40 refusals and 8 allowances across both edges.

Mutations: swapped version action, redirected resource, ignored denial,
and bypassed Served authorization failed the permission or HTTP checks.
Earlier effective mutations covered body copying, premature owner drop,
range status, missing 304 headers, a 304 body, wrapped stream error causes
and duplicate accounting. No assertions were removed or weakened.

Linux RDMA paths were not compiled or exercised. GetObjectAttributes,
PutObject gateway registration and the default-stack switch are not part
of this increment.
2026-11-15 07:40:48 +08:00
overtrue b7e7a6156c feat(gateway): serve bucket notification configuration reads
Use native gateway DTOs for stored notification reads, register the handler,
and keep both edges on the shared bucket authorizer. The legacy edge now
uses the compatibility seam. Notification writes and the default stack are
unchanged. Non-test changes: +53/-36 lines.

Add three refusal-oriented tests and two configuration-read tests, including
successful IAM controls. Cover absent and stored configurations, reserved
bucket shapes, unknown stored XML, event/filter values, bucket-bound IAM
allow/implicit deny/explicit deny, and one handled-operation count.

Mutation controls on da5414c: bypassing each edge's authorization made its
notification_authorization_binds_the_bucket_on_the_*_stack test fail because
the wrong bucket was served. Dropping the stored queue made both
*_stack_answers_the_stored_notification_configuration tests fail. Restore
hashes were checked and sources were touched before a real rebuild.

Validation: 279 scoped tests passed on da5414c; 70 scoped tests passed after
rebasing to fd8dc41. Both rustfs all-target Clippy builds passed on fd8dc41,
as did fmt, test wiring and prepush-quick. Script tests passed on da5414c.
The earlier broad run reported one existing CORS test as leaky with exit 0.
CI and the full workspace suite were not run.
2026-11-15 06:08:43 +08:00
Hauser Zhi 9075131b23 feat(grpc): bind peer capability to connection generations (#9433)
* feat(grpc): track physical connection generations

Observe every tonic physical reconnect through a stable custom connector while preserving existing TCP, TLS, HTTP/2, cache, and public channel behavior.

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

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

* feat(rpc): bind msgpack capability to connections

Scope authenticated msgpack observations to channel identity and physical connection generation so transparent reconnects require a fresh proof without enabling the send policy.

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

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

---------

Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-15 04:10:18 +08:00
Hauser Zhi 050be16dc7 feat(rpc): authenticate msgpack peer capability
Add an optional boot-epoch-bound HMAC capability proof and cache the verified per-peer observation without enabling any msgpack send policy.

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

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 02:55:45 +08:00
Hauser Zhi 8efa1a96c0 chore(deps): pin nixl-sys workspace source
Manage the nixl-sys Git revision from the workspace dependency table and point the optional Linux transport dependency at houseme/nixl commit cc636c83f13d692e85b67e55aed092413d16fb41.

Allow the reviewed source in cargo-deny and refresh the lockfile, replacing the unmaintained bincode dependency with the fork's wincode graph.

Co-Authored-By: heihutu <heihutu@gmail.com>
Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 01:47:37 +08:00
Hauser Zhi 444dbd9956 test(multipart): run refusal matrix on large stack
Run the real-store completion refusal matrix through the shared 32 MiB test harness so its deep async storage future does not overflow libtest's default stack.

Keep the original test name and all refusal-order assertions intact.

Co-Authored-By: heihutu <heihutu@gmail.com>
Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-15 01:31:09 +08:00
overtrue df4c4916c2 refactor(storage): own the PutObject write core
Use RequestEnvelope, a native upload body, raw write fields and owned results in the PutObject core. Legacy and RDMA ingress project once; internal writes share the core. Preserve archive batching, shared SSE and object-lock validation, completion ownership, audit events and response facts. Keep the merged RDMA length, cache lifetime and response-header behavior.

No gateway registration or UploadPart migration is included. Source outside test files/modules: +820/-383 (including conditional test imports).

Validation on fd8dc41f0c: fmt; default and gateway-stack all-target Clippy; 903 scoped tests with RUST_MIN_STACK=4194304; script-tests; test wiring; prepush quick checks. The archive authorization matrix has six refusal cases and three allowed cases, with persisted object/metadata checks. A fixed a279 legacy TCP baseline has 48 matching response records; the two retained socket tests cover PUT and POST behavior. The recorder observes drained counter deltas alongside the official cumulative 0/1/2/3 operation totals.

Mutation evidence: 44 distinct faults, grouped below by the test that rejected them. The counter and archive authorization additions each passed an unflagged control before their five mutations. The other fault controls and failures were retained from the same unchanged implementation.

- app::object::native_body::tests::legacy_body_preserves_demand_pending_and_length_validation_location: body-eager, body-length
- app::object::native_body::tests::legacy_producer_error_keeps_its_concrete_type_and_is_not_eof: producer-source
- app::object::native_body::tests::internal_producer_error_preserves_io_kind_and_nested_source_after_data: producer-source
- app::object::native_body::tests::native_trailers_are_published_only_at_eof: trailer-pending, trailer-value
- app::object::native_body::tests::native_framing_and_classified_errors_are_not_unwrapped: native-byte-count, native-class, native-kind
- storage::ecfs::legacy_edge::object_write::native_put_tests::legacy_projection_defers_invalid_raw_values_to_the_existing_validators: input-bucket, input-key, input-storage_class, input-server_side_encryption, input-object_lock_mode, input-object_lock_legal_hold_status
- storage::ecfs::legacy_edge::object_write::native_put_tests::legacy_projection_keeps_each_checksum_and_unknown_length: input-checksum_crc32, input-checksum_crc32c, input-checksum_sha1, input-checksum_sha256, input-checksum_crc64nvme, input-length, input-trailer
- storage::ecfs::legacy_edge::object_write::native_put_tests::owned_response_projection_preserves_status_headers_and_all_checksums: output-e_tag, output-checksum_crc32, output-checksum_crc32c, output-checksum_sha1, output-checksum_sha256, output-checksum_crc64nvme, output-status, output-headers
- app::object::put::tests::put_read_quorum_failures_are_normalized_at_each_stage: error-status, error-message, error-source
- app::object::put::tests::put_commit_lock_failure_keeps_request_operation_in_spawned_owner: error-headers
- app::object::put::tests::cancelled_put_request_completes_post_commit_publication: completion
- app::object::shared::tests::build_put_like_object_lock_metadata_rejects_mode_without_retain_until_date: lock-pairing
- app::object::shared::tests::build_put_like_object_lock_metadata_rejects_retain_until_date_without_mode: lock-pairing
- storage::ecfs_test::tests::test_parse_object_lock_retention: lock-presence
- app::object::extract::tests::snowball_member_mtime_requires_member_replication_authorization: archive-replication
- table_catalog::tests::put_object_reserved_prefix_guard_rejects_broken_native_delegation: guard-reason
- object_write::legacy_owned_put_preserves_refusal_order_checksums_and_short_body: refusal-priority, output-headers, output-checksum_crc32
- app::object::put::tests::put_edge_counts_polled_requests_once_before_usecase_refusal: count-missing, count-double
- app::object::extract::tests::snowball_owned_member_privileges_gate_storage: archive-tagging, archive-retention, archive-legal_hold

Existing expected values are unchanged.

Not verified: CI, Linux RDMA execution, performance, and gateway native-frame trailer consumption through this business core. The native trailer adapter itself is covered; gateway integration is a separate increment. The local suite uses a 4 MiB stack and makes no claim about default-stack behavior.
2026-11-15 01:20:53 +08:00
Hauser Zhi 33e0fe8c6f Merge remote-tracking branch 'origin/main' into fix/pr9420-multipart-stack 2026-11-15 00:32:04 +08:00
Hauser Zhi fd8dc41f0c feat(ecstore): add file-sync durability tier (#9422)
* refactor(ecstore): split durability sync capabilities

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

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

* refactor(ecstore): classify durability barriers

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

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

* feat(ecstore): add file-sync durability tier

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

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

* test(storage): harden durability docker validation

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

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

* test(storage): isolate durability PUT benchmarks

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

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

* test(storage): expose file sync grouping controls

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

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

---------

Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-15 00:17:34 +08:00
Chris An 645bb63809 feat: S3-over-RDMA with NIXL and cuObject transports (#9394)
* feat: S3-over-RDMA with NIXL and cuObject transports

A signed S3 request with an empty body names a registered client buffer; the server moves the object bytes with one-sided RDMA (NIXL/UCX, or NVIDIA cuObject through the cuobject crate) instead of the HTTP body. Internode shard reads and writes can also move over NIXL.

Applied onto main from #9305 (head 0f3c19a0f); the stacked #9302-#9304
commits are already on main as eca95f297. Conflicts were resolved where
this change met newer main: crates/ecstore/src/api/mod.rs (kept the
internode-transport exports, added the nixl module),
crates/rio/src/http_reader.rs (internode_http_request uses the pooled
get_http_client::<false>), rustfs/src/storage/rpc/http_service.rs
(write_authenticated_put_file stays a plain fn returning a future, now
pub(super)), rustfs/src/app/multipart_usecase.rs (the RDMA UploadPart
branch moved into multipart_usecase/upload_part.rs after the
per-operation split), Cargo.lock (main's lock plus only this change's
new packages).

* fix(rdma): build the RDMA crates without vendor SDKs and pass guards

Maintainer changes on top of the contributed S3-over-RDMA work:

- rustfs-cuobject: cuobject is an optional, default-features = false
  dependency behind a new `server` feature (enabled by the rustfs
  `cuobject` feature); the crate root is #![cfg(feature = "server")], so
  without the feature it exports nothing and a workspace build needs no
  NVIDIA cuObject SDK.
- The NIXL agent handle (OnceLock, install_nixl_server, nixl_server)
  moved from app/object/cuobject.rs to storage/rpc/nixl_read.rs; the app
  init installs it. The layer-dependency guard rejects infra -> app.
- New code reaches ECStore through a cfg-gated `ecstore_rdma` facade
  module and s3s types through the existing re-export hubs
  (architecture-migration and s3s-footprint guards).
- SAFETY notes at the two #[allow(unsafe_code)] sites, inside the window
  the unsafe-allowance guard checks.
- transport_config_known_backends_are_current_oss_values loops over
  KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS again, expecting nixl to name
  itself.
- New non-required workflow rdma-feature-check.yml runs
  `cargo check --locked -p rustfs --features nixl` on Linux (paths
  filter, weekly, manual), registered in scheduled-validations.json.

* fix(ecstore): keep NIXL internode error messages constant

The three io::Error::other(format!(..)) sites in nixl_internode.rs
(read refused, write refused, write byte-count mismatch) now return
constant messages; the status, response body length and byte counts go
to a debug! line in the same place, the level this file already uses for
a failed NIXL peer call. No response body is logged, as on the HTTP
internode path.

The error-format ratchet exists because per-disk formatted messages make
otherwise identical errors compare unequal and split the quorum
reduction; constant messages keep them in one bucket. A typed transport
error would carry the detail without that problem; this takes the
mechanical route.

* fix(ecstore): flush staged NIXL writes before waiting for buffers

* fix(rdma): build rustfs-nixl only on Linux

nixl-sys's stub build links -lstdc++, which macOS does not ship, so
`cargo test -p rustfs-nixl` (and a workspace test run) failed to link on
macOS. rustfs-nixl's dependencies are now Linux target dependencies and
its crate root is #![cfg(target_os = "linux")]; the rustfs `nixl`
feature code that was not already Linux-gated (the storage/rpc nixl_read
module, open_shard_contained, the internode route arms and the facade
module) is now cfg(all(feature = "nixl", target_os = "linux")). Linux
builds are unchanged: the workspace tests still build and run the
crate's tests through the stub.

* ci(rdma): alert on scheduled failures of the RDMA feature check

The test-wiring guard requires every scheduled validation workflow to carry the shared alert-on-failure job; a failed weekly run now opens or updates the tracking issue like the other scheduled lanes.

* fix(rdma): put rustfs-nixl behind a sys feature

nixl-sys needs a C++ compiler and libclang (bindgen) to build, which the shared Linux runners do not have, so Workspace Clippy and Lint and Build failed once the crate compiled there. Its dependencies are now optional behind a 'sys' feature that the rustfs 'nixl' feature enables; without it (and off Linux) the crate is empty, so no default or workspace build touches vendor C/C++ tooling. The RDMA feature check now also runs the crate's unit tests with the feature on; they use a fake sysfs and host memory, no device.

---------

Signed-off-by: Hauser Zhi <housemecn@gmail.com>
Co-authored-by: Rain Jiang <rain-jiang@outlook.com>
Co-authored-by: Hauser Zhi <housemecn@gmail.com>
2026-11-15 00:10:10 +08:00
Hauser Zhi 5f9e5d62df feat(obs): measure remote rename field bytes (#9417)
* feat(obs): split PUT commit and remote rename timing

Measure the app commit-owner scheduling gap and split remote rename client
preparation into compatibility encoding, client acquisition, and request digest
stages. Keep the timers behind the existing detailed PUT diagnostics gate.

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

* bench(filemeta): measure inline rename RPC encoding

Compare JSON compatibility, msgpack, and dual encoding for metadata-only and
representative inline FileInfo payloads used by remote rename requests.

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

* fix(bench): use exact inline rename shard fixture

Model the 100 KiB EC12 inline data as one rounded data shard plus its
HighwayHash header, and report metadata-only throughput as operations.

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

* feat(obs): measure remote rename field bytes

Record detail-gated JSON and msgpack field lengths after successful remote
rename request encoding so msgpack-only rehearsals can prove sender behavior.

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

* test(scanner): preserve partial carry drain window

Use the production drain window for real partial-bucket checkpoints so CI storage latency cannot truncate source-cache persistence.

Align the certified partial-cycle assertions with carried-value semantics while retaining mixed-coverage and final convergence checks.

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-15 00:00:09 +08:00
Hauser Zhi 205227b441 feat(obs): add exact HTTP/2 ping timeout diagnostics
Co-Authored-By: heihutu <heihutu@gmail.com>
Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-14 22:04:11 +08:00
overtrue da5414c345 fix(protocols): preserve HeadBucket storage root compatibility
Resolve empty-bucket requests through the existing storage lookup at the
legacy edge. Keep authorization, operation counting and nonempty bucket
conversion unchanged. No gateway bucket-name contract changes.

Add two tests covering two positive and two negative cases: protocol root,
ordinary bucket, missing bucket and uninitialized storage. Check response
status/headers and one count per request. Disabling the compatibility
branch makes both tests fail; restoring it passes both after recompilation.

Verified on 4182d55d1: focused tests, gateway Clippy, and a rebuilt binary
with libunftp 0.25 using FTP_TLS: login 230, root and ordinary CWD 250,
missing bucket 550. Default Clippy and script-tests passed on 925e5d0c0.
After integrating a279b4bb6, gateway Clippy and prepush-quick passed.
The wire probe and focused tests were not rerun after that integration.
2026-11-14 20:57:53 +08:00
overtrue a279b4bb63 feat(gateway): serve owned multipart completion
Use shared request authorization and native completion responses across both S3 stacks. Keep storage responsible for final commit and replay decisions.
2026-11-14 20:42:23 +08:00
Hauser Zhi 3e5d37742d fix(grpc): attribute rebuild success after publication
Co-Authored-By: heihutu <heihutu@gmail.com>
Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-14 20:08:49 +08:00
Hauser Zhi 8e6265907a perf(grpc): attribute rebuilds and bound bulk responses
Co-Authored-By: heihutu <heihutu@gmail.com>
Co-Authored-By: zhi22915 <qiuzgang@gmail.com>
2026-11-14 19:59:06 +08:00
Hauser Zhi 4182d55d11 chore(deps): upgrade JWT and FTP dependencies (#9419)
Update jsonwebtoken to 12.0.0 and libunftp to 0.25.0, including the JWT key construction API changes required by the new release. Refresh the lockfile through two requested cargo update and cargo upgrade rounds.

Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-14 09:11:54 +00:00
Hauser Zhi d4af2377fe perf(grpc): prewarm isolated bulk channels (#9418)
perf(grpc): prewarm isolated bulk channel pools

Extend the existing opt-in peer prewarm to the configured bulk channel pool. Control prewarm remains one channel, isolated bulk prewarm fills the per-peer pool, and legacy shared mode reuses the control cache. Add a cache-reuse regression for the legacy mode.

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-14 09:02:49 +00:00
Ramakrishna Chilaka f5e8f17461 perf(ecstore): coalesce shard, integrity index, and commit syncs (#9407)
* perf(ecstore): coalesce shard, integrity index, and commit syncs

- Enable sync-on-close (WriteMode::TruncateSync with sync_parent_dir: false)
  in LocalDisk::create_file for multipart staging writes so part.N and
  part.N.integrity.<gen> run fdatasync before POSIX_FADV_DONTNEED page-cache
  reclaim and register in PRESYNCED_TMP_FILES without polluting
  PRESYNCED_TMP_DATA_DIRS.
- Keep LazyLocalFileWriter open across write_bitrot_shard when shard integrity
  is enabled and coalesce the .idx sidecar creation, write, and fdatasync into
  poll_shutdown via set_pending_integrity_index + MultiWriter::finish_and_shutdown,
  skipping duplicate PreparedIntegrity::write file creations for prewritten disks.
- In fused_attempt (commit.rs), sync prepared_metadata_source (xl.meta) before
  os::fsync_dir_std(src_data_path) when src_data_path is presynced so the
  active journal transaction commits both xl.meta data extents and the staged
  data directory entry in one flush instead of two.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 21d8304f-0f49-48eb-8c28-26f3689b081b

* perf(ecstore): skip redundant .idx parent creation and header re-read when presynced

- Mark parent_exists = true in StdBackend::open_write for temporary .integrity.
  and .proof. sidecars so open_lazy_local_file_std opens the file directly in
  its existing staging directory before falling back to create_dir_all_std.
- Skip reopening and re-reading the 32-byte .idx header in
  LocalDisk::prepare_part_transaction when take_presynced_tmp_file confirms the
  sidecar was just written and synced by LazyLocalFileWriter.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 21d8304f-0f49-48eb-8c28-26f3689b081b

* fix(ecstore): validate presynced multipart integrity indexes

Validate the proof file type, length, and header before preparing a multipart transaction. Use a presync receipt to skip the redundant file sync after validation.

Cover valid, truncated, and mismatched-header indexes carrying presync receipts.

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

* test(ecstore): wait for tail rename drain in inline_put_direct_commit_handles_post_encode_rename_failures

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 21d8304f-0f49-48eb-8c28-26f3689b081b

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: Hauser Zhi <housemecn@gmail.com>
Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
Copilot-Session: 21d8304f-0f49-48eb-8c28-26f3689b081b
2026-11-14 18:03:56 +08:00
overtrue 925e5d0c0c feat(gateway): serve HeadObject through native response facts
Share HEAD authorization and its use case across both request edges. Keep
stored and proxy ETag parsing distinct, preserve conditional headers and
version bytes, and finish auditing before terminal header encoding. Pin
gateway to 1afff6a for the measured 304 response profile.

Verified 785 affected and embedded tests, then 12 tests after test-only
module/import cleanup. Both all-target Clippy configurations, script tests,
wiring and prepush checks passed. Tests cover malformed stored tags,
separate replication denial, conditional status conflicts and ordinary
success controls; the proxy oracle checks 779 spellings.

Observed 39 effective isolated faults: authorization/delegation, execution,
metadata exposure, stored/legacy/proxy tags, raw header escaping/repetition,
framing conflicts, length/counting, range boundaries, checksum and storage
class, ordinary completion, terminal code/status/default resolution, and
each of the seven 304 fields. An ineffective fallback mutation was retained
as a failed experiment and replaced with an explicit-status-only fault.

The 785-test base was c13232996; final module tests and Clippy ran on
fc22c11d1. No GetObject migration added. Cross-binary pinned acceptance,
remote proxy/ODM integration, SSE-C real-storage wire and performance were
not verified. Existing assertions were not weakened.
2026-11-14 17:54:44 +08:00
Hauser Zhi 247aecf7b8 fix(health): bound quorum probes and readiness observations (#9410)
* fix(health): bound quorum probes and record timeout observations

Collect fresh local and remote observations concurrently and finish once
each configured set has sufficient storage and lock quorum evidence.
Validate configured peer identities and disk slots before counting votes.

Apply the cluster deadline to cache and singleflight waiting, retain flight
ownership through timeout publication, and record timeout observations once.
Cover slow peers, unavailable quorum, identity validation, cancellation,
cache ownership and compatibility with focused regressions.

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

* perf(health): coalesce probes and count quorum incrementally

Share the completion generation with overlapping uncached requests while
retaining fresh observations for later requests and bounded flight ownership.
Build validated topology thresholds once and count unique disk and lock
votes incrementally instead of rescanning collected inventories.

Honor the existing inventory metrics flag through RPC and storage owners.
Health probes omit operation metric snapshots while retaining fresh disk
identity, capacity and runtime checks. Move owned inventories across local
aggregation layers and preserve the full-metrics administrative APIs.

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

* test(health): cover failed uncached flight recovery

Cover a later waiter sharing its overlapping failed round before an independent request starts a fresh successful observation.

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

* perf(health): group lock membership in one endpoint pass

Group configured lock members by set in one pass and reject impossible set counts before allocation. Retain per-set thresholds and add a bounded malformed-topology regression.

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

* test(health): publish startup topology in gating fixture

Publish the shared four-disk fixture's endpoint topology before initializing disks, matching storage startup. Cluster health probes can then validate fresh quorum observations while the readiness test exercises S3 admission publication.

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-14 06:24:21 +00:00
Hauser Zhi fc22c11d1a feat(obs): split PUT commit and remote rename timing (#9416)
* feat(obs): split PUT commit and remote rename timing

Measure the app commit-owner scheduling gap and split remote rename client
preparation into compatibility encoding, client acquisition, and request digest
stages. Keep the timers behind the existing detailed PUT diagnostics gate.

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

* bench(filemeta): measure inline rename RPC encoding

Compare JSON compatibility, msgpack, and dual encoding for metadata-only and
representative inline FileInfo payloads used by remote rename requests.

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

* fix(bench): use exact inline rename shard fixture

Model the 100 KiB EC12 inline data as one rounded data shard plus its
HighwayHash header, and report metadata-only throughput as operations.

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-14 16:19:00 +08:00
overtrue 0eec25e4c0 fix(ci): compile gateway features in nightly matrix legs
Select gateway-stack for replication and protocol gateway legs and use matching build and run features. Legacy feature selections remain unchanged.

Verified on 0460ad63a: 20 e2e binary tests, full make script-tests, actionlint with shellcheck, CI workflow check, and prepush quick checks. The workflow contract exercises four passing build/run selections, four propagated failures and four mismatched-feature rejections. Removing either gateway feature, mismatching either run selection, and emptying the matrix each made the contract test fail.

No Rust compilation or live nightly execution was performed; actual gateway startup and suite outcomes remain to be observed in CI.
2026-11-14 15:28:03 +08:00
cxymds c132329961 fix(scanner): preserve usage convergence across bounded cycles (#9397)
* feat(usage): record bucket provenance and complete observations

* fix(scanner): preserve usage progress across bounded scan cycles

* docs(scanner): explain usage provenance and bounded convergence

* chore(scanner): correct requeuing spelling in runtime guidance

* fix(scanner): route usage contracts through domain facades

* fix(usage): keep admin projection futures sendable

* fix(scanner): expose endpoint layout in production facade

* fix(scanner): preserve checkpoint ownership during budget drain

* test(scanner): remove redundant fixture clones

* test(ecstore): update Windows rename publication calls

* fix(ci): restore scanner test exports and lint assertions

* test(scanner): preserve production drain for real checkpoints

* fix(scanner): retire obsolete work without clearing responsibility

* test(table-catalog): follow DeleteObject guard delegation

---------

Co-authored-by: Hauser Zhi <housemecn@gmail.com>
2026-11-14 15:07:51 +08:00
cxymds 0f503fc613 feat(admin): expose caller-bound effective permissions (#9414)
* feat(admin): add caller-bound effective permission queries

Expose bounded advisory checks through the existing IAM, bucket-policy, table, and KMS authorization paths. Preserve three-state decisions for incomplete request facts and bypass publication guards only for internal probes while real operations continue to authorize independently.

* fix(auth): preserve effective permission probe boundaries

Use canonical action scopes and verified signing facts, keep unavailable conditions unknown across table metadata gates, and resolve table resources without catalog repair. Route admin test dependencies through existing facades and keep legacy S3 error usage within its migration baseline.
2026-11-14 15:07:24 +08:00
overtrue 0460ad63a0 feat(ecstore): add read-only multipart completion bindings
Observe active, completed and retained multipart ownership without replay, recovery, acknowledgement or reclamation. Only active uploads supply preflight metadata. Completed and retained records require validated physical evidence; completion still owns publication.

Preserve native inspection errors before reporting absence. Completed quorum retains precedence, and UnsupportedDisk keeps its compatibility behavior.

Validation: 17 binding tests and all 7,453 ecstore tests passed with four workers and no skips. Both default and internode-transport,test-util all-target Clippy passed with warnings denied. Formatting, script tests, test wiring and prepush checks passed.

Combined mutations of inspection error propagation, read quorum selection and UnsupportedDisk handling produced four intended runtime failures while two controls passed. Sources were restored by hash and actually recompiled before the full final run.

Application and CompleteMultipartUpload integration are not included.
2026-11-14 14:01:10 +08:00
Nonot 28da2e12a8 feat(initContainer): add resource configuration for init containers (#9400)
Co-authored-by: Hauser Zhi <housemecn@gmail.com>
2026-11-14 13:01:38 +08:00
overtrue 41225da343 fix(ci): provision runtime tools for both full nightly stacks
Reuse the full CI job's pinned mc and Vault provisioning, version checks,
and iptables capability warning before both e2e-full nightly stack runs.
Keep existing test filters, profile selection and report-only policy.

Validation on 4053e694c: actionlint with shellcheck, YAML step equivalence,
test wiring, CI workflow contract, prepush-quick and full script-tests.
The first script-tests attempt hit an unchanged scanner fixture JSON read;
the fixture control and final full rerun passed without source changes.
This does not establish the cause or repair of that fixture failure.

Executed the fixed Linux mc and Vault downloads, SHA-256 checks and version
commands in a private prefix. No test assertions were added or changed
(negative/positive 0/0); no mutations or Rust builds were needed.
The complete nightly workflow and E2E cases were not run for this change.
2026-11-14 12:50:34 +08:00
overtrue 4053e694cb feat(storage): carry native values through shared SSE
Keep SSE configuration, requests, materials and read response fields on
native strings. Project legacy enums at the DTO boundaries and retain the
existing validation order, bucket defaults and KMS authorization behavior.
Carrier diagnostics omit customer keys and encryption key material.

Production lines: +186/-166. Add 5 negative diagnostic tests, 0 positives.
Do not implement or register an owned PutObject operation.

Validation: fmt, default and gateway-stack all-target Clippy, 777 affected
unit tests, script-tests with aligned Python, test wiring and prepush-quick.
Tests ran on 9ea8e8d37f9670f8da3dc5cb6ed5fe6e6e9bb592; rebased onto
a9dd5f0fd1 with no overlapping files or pin change.

Mutation witnesses (8 sites, 9 failing cases): restore derived Debug for
SseTypeV2, EncryptionRequest, DecryptionRequest, EncryptionMaterial and
DecryptionMaterial -> all five native_*debug_withholds* tests fail; change
unknown default mapping -> shared and copy unknown-default tests fail;
admit an unsupported algorithm -> rejects_invalid_sse_algorithm fails;
project AES reads as KMS -> classification_withholds_the_wrapping_key_for_sse_s3_reads fails.
Restore exact source hashes, touch the SSE source and rebuild: 777/777 pass.

Not verified: full workspace, optional rio-v2/FIPS builds, or CI for this commit.
No intended legacy protocol change; diagnostics intentionally omit key fields.
2026-11-14 12:25:38 +08:00
overtrue a9dd5f0fd1 test(cache): observe entry destruction before claim release
Moka maintenance can logically evict an entry while epoch reclamation still
owns its allocation. Check a cache miss, tear down the cache, and observe
entry destruction through Weak before asserting response ownership and the
final reservation release. Keep the original five-byte and zero-byte checks;
only their physical-owner precondition changes. No runtime behavior changes.

Validated on 4bb272ed6 with default cache/runtime-memory features on macOS:
140 package tests passed, all-target Clippy, formatting, test wiring, and
prepush quick checks. Linux has one extra cgroup-only test, not run locally.

Mutation checks: copying response bytes breaks the live claim assertion;
skipping reservation release breaks the final zero assertion; retaining an
entry breaks the Weak assertion; skipping cache removal breaks the miss
assertion; detaching the response after eviction breaks the post-teardown
five-byte assertion. All failed through their intended runtime assertions.
No tests added or removed. No cache policy or reclamation timing changes.
2026-11-14 11:58:09 +08:00
overtrue 4bb272ed64 fix(gateway): honor the SSE-C transport setting
Reuse the outer transport layer's deployment setting in the gateway builder. The existing false default allows customer keys over plaintext with the gateway's explicit acknowledgement; true keeps both key sides strict. Transport facts remain per request.

The shared signer fixture now accepts headers before signing. The new test exercises 45 scenarios (38 refusals, 7 test-handler successes), checks signed SSE headers and raw-key handoff, and runs the inner plaintext gate separately from the outer layer.

Validation on ebe31dfdb5: fmt, all-target Clippy with and without gateway-stack, test wiring, and 63 gateway-stack/handler/transport tests passed. Production diff: +29/-14 lines.

Fault controls fail ssec_deployment_policy_and_key_handoff: forced strict/allow, false secure transport, re-signed key/input rewrites, skipped handler, response-key echo and wrong refusal code. Separate fixture checks reject anonymous allowance and unsigned SSE headers. The original strict selector fails a valid signed plaintext request with InvalidRequest after a TLS handler control succeeds.

Not verified: copy-source key wire handoff, storage use cases, real Served IAM authorization, network TLS termination, cutover acceptance or CI. No production operation was added.
2026-11-14 10:46:32 +08:00
overtrue 9ea8e8d37f fix(deps): align bindgen and prettyplease on syn 3
Restore only bindgen 0.73.2's syn edge to the already locked syn 3.0.10.
Its >=2,<4 range permits this version and prettyplease 0.3 requires syn 3.
No package version, checksum, manifest, feature or formatter changes.

Regression evidence: the frozen lock failed the FIPS tls-runtime test
build with E0277 in bindgen's prettyplease::unparse call. The corrected
locked graph builds and runs provider_policy_isolated in both modes.
No new tests or assertions; no behavior mutation was needed for this
compile failure. Product source lines changed: 0; lock lines: +1/-1.

Verified: tls-runtime all-targets Clippy and provider_policy_isolated
(1 passed in each mode), default on ebd4bb2ba and FIPS on f2a43376d.
The final rebase only adds two test-guard fixes. cargo tree --locked,
fmt, diff whitespace and prepush-quick passed on the final base.

Not verified: full RustFS/workspace suites, the remaining nightly FIPS
consumer matrix, or a new Linux CI run. No runtime TLS policy changed.
2026-11-14 10:35:45 +08:00
overtrue f2a43376de test: adapt owned entrypoint guard fixtures
Follow DeleteObject's typed and legacy entrypoints through the shared fields adapter into its owned implementation. Preserve the existing mutation guards and key/prefix/store ordering checks.

Let the TRACE mutation probe locate either ListObjectsV2 parameter shape exactly once, then require the real logging guard to reject DEBUG.

Validation on ebd4bb2ba8: default and gateway-stack all-target Clippy, three focused nextest tests, full make script-tests, split probe (61 checks), test wiring, shell syntax, and prepush-quick passed. Product lines: +0/-0.

Source-guard evidence: one valid source control and 11 negative fixtures; missing methods, bypassed delegation, missing guards, and reversed ordering fail with the intended diagnostic. The old checker fails on current source. Disabling each typed, legacy, or fields delegation check makes the fixture test fail. TRACE marker evidence: two accepted shapes and five rejected missing/debug/duplicate shapes; TRACE-to-DEBUG mutation is rejected by the real logging guard.

No runtime code or logging policy changes. Full workspace and Linux CI were not run locally; source-guard mutations do not prove runtime authorization.
2026-11-14 10:12:26 +08:00
overtrue ebd4bb2ba8 feat(gateway): serve object and multipart-upload listings
Move ListObjects, ListObjectsV2, ListObjectVersions and ListMultipartUploads
to owned use cases and gateway handlers. Keep legacy encoding, stored ETags,
optional facts and cursor boundaries at their existing edges. ListParts and
multipart create/complete/abort are outside this increment.

Non-test changed lines: +973/-659, excluding test modules and test-only
imports/reexports; comments and whitespace are included.

Validation: 282 focused tests passed on ed3a9e670d,
including all storage::access::tests and both stack refusal matrices. The four
listing matrix rows exercise 32 refusals and 8 allowed requests across both
stacks; these are migrated coverage, not 40 new tests. Stored-key, entity-tag,
encoding and pagination tables provide additional compatibility coverage.
The 1024-byte stored-key positive runs on Linux; macOS attempts the write and
asserts FileNameTooLong and absence because of its full-path limit.

Final RustFS all-target Clippy passed with and without gateway-stack on ed3a9e670.
The affected e2e_test package Clippy passed on e3858df4fa.
After rebasing over the adjacent response-helper change, one gateway-stack
all-target cargo check passed on ebe31dfdb5.
Formatting, test wiring, seam validation and prepush-quick passed.

Ten effective local mutations were reviewed on d5f640243952b571111bb3c97a98850f04a92172:
- Count: key_count_includes_objects_and_prefixes_and_a_keyless_entry_is_not_an_object.
- Marker: list_objects_next_marker_follows_the_cursor_then_the_last_raw_entry.
- Key floor: every_key_the_store_can_hold_is_represented_unchanged.
- Nil version: versions_delete_markers_and_markers_are_answered_raw.
- Upload fields: list_multipart_uploads_output_maps_uploads_and_prefixes_raw.
- XML escaping: listing_entries_are_encoded_per_segment_only_for_url_and_tags_are_escaped
  and the_legacy_stack_lists_every_stored_entity_tag.
- Three direct authorization mutations (ListObjectsV2, ListObjects,
  ListObjectVersions): the_refusal_matrix_holds_on_the_gateway_stack.
- Shared multipart authorization: both stack refusal matrices; this also covers
  ListMultipartUploads delegation. Its separate direct early-return experiment
  failed for a root request and is excluded from authorization evidence.
All temporary experiment code was removed before the final product build.

Not verified: full dual-stack differential run, full workspace CI, or Linux
runtime execution locally. Bootstrapping operations for the differential suite
are not all migrated yet. Historical wire baselines cover a narrower surface.
2026-11-14 09:23:04 +08:00
overtrue ebe31dfdb5 feat(app): carry answered status and headers across both edges
Add Answered<Output> for use cases that return a status override or extra
response headers. The legacy seam preserves those fields on S3Response;
the gateway helper passes them to Resp through its supported API. Bare
outputs share the seam implementation and retain their default response.
No operation consumes the carrier yet. Non-test changes: +87/-4 lines.

Validated on ed3a9e670d:
- cargo clippy --locked -p rustfs --all-targets -- -D warnings, both
  default and --features gateway-stack.
- cargo nextest run --locked -p rustfs --features gateway-stack --lib
  --no-tests fail -E 'test(storage::ecfs::legacy_edge::tests) |
  test(server::gateway_handlers::tests)': 23 passed.
- cargo fmt --all --check, prepush-quick, test wiring, CI workflow
  contract and validation registry passed.

Three added tests cover carrier values and defaults (0 refusal / 3
positive tests). Representative mutations discarded status and headers
on both edges: an_answered_status_and_headers_reach_the_legacy_response_unchanged
failed its status assertion; the corresponding gateway answer test
failed its status/header tuple. Both tests ran and failed. Restore hashes
matched and sources were touched before the passing ordinary rebuild.

Not verified: wire header delivery or encoder-owned/header-collision
refusals; these belong with the first HeadObject/GetObject consumers.
The legacy header assertion was not independently mutated. No new
operation, authorization path, wire claim, or legacy operation behavior
change is included. Full workspace tests and CI were not run locally.

Refs: rustfs/backlog#2767, rustfs/backlog#2734
2026-11-14 09:07:52 +08:00
overtrue ed3a9e670d feat(gateway): serve DeleteObject on both stacks
Move DeleteObject to an owned use case and share authorization between the legacy and gateway edges. Keep the legacy request fields at the entry so validation and audit run in order. Give the refusal matrix its own bucket.

Tests: 168 passed on e97dc74d9; the restored mutation control passed 9 tests before an equivalent test-only Clippy fix. RustFS Clippy passed in both configurations; e2e_test Clippy and test wiring passed. The recursive authorization table covers 24 refusals and 16 allows. The header and caller tables add three refusals and five allows across both request forms; the wire cases add key, version and caller refusals.

Mutations: bypassing the primary, force, authenticated-caller, or governance decisions turned their refusal cases into allows. Skipping descendant delete, replication, or bypass decisions turned the respective refusal rows into allows. Removing context restoration failed both allowed and refused rows. Disabling the helper removed the invalid-key audit. The gateway root matrix stayed green for each mutation except the primary decision, where its root row passed and the unauthorized rows were served.

Not verified: the full dual-stack differential scenario requires PutObject and bucket versioning on the gateway stack. CI has not run for this candidate.
2026-11-14 07:55:37 +08:00
overtrue e3858df4fa feat(gateway): serve object metadata operations
Serve object ACL reads and writes, legal hold and retention reads, tagging reads and deletes, and torrent requests through shared use cases and authorization.

On base af93bf466, 131 object metadata and access tests, four refusal matrix tests, and five targeted behavior controls passed. Mutations covered each authorization, version actions, retention UTC conversion and range, ACL responses, tags, lock checks, missing objects, version parsing, and store initialization. Both package clippy configurations passed.

After rebasing onto e97dc74d9, the gateway-stack all-target check and all four refusal matrix tests passed. Full workspace tests and differential scenarios were not run.
2026-11-14 07:36:21 +08:00
overtrue 8e64a3aa2f feat(server): configure gateway bucket owner source
Use the owner ID RustFS reports for gateway expected-owner checks. A missing bucket is still resolved by its handler; no per-bucket owner lookup is added.

The gateway wire table covers six refusals and four successes across ordinary, missing, and reserved-shaped buckets and ListBuckets. The same table runs against the legacy stack. The source unit test covers a reported owner and an unavailable owner.

Mutations: removing the source makes the gateway table fail; returning the wrong owner makes the gateway table and owner unit test fail; returning the wrong owner only for the missing bucket changes its matching-owner response from 404 to 403; returning an owner when none exists makes the owner unit test fail.

Verified against base e97dc74d9: both RustFS clippy configurations, three focused tests, test wiring, and prepush quick checks. Successful SDK responses are checked as success, without asserting their HTTP status. Full workspace tests and CI were not run locally.
2026-11-14 07:33:47 +08:00
overtrue 092c8c272d test: accept owned bucket in metadata reload guard
Verified both bucket guards, default and gateway-stack Clippy, formatting, test wiring, and prepush checks. Removing the CORS notification and flipping its maintenance flag each failed the guard; the restored control passed.

Tests ran on e97dc74d9 before rebasing over unrelated KMS changes at 3c59e4f30. Full workspace tests were not run locally.
2026-11-14 07:32:45 +08:00
唐小鸭 3c59e4f306 fix(kms): tolerate Vault reads that lag the client's own writes (#9406)
* fix(kms): tolerate Vault reads that lag the client's own writes

A Vault or OpenBao node that answers reads from its own copy (an OpenBao standby, a Vault Enterprise performance standby) can serve the state from before a write for a short while after acknowledging it, and can refuse a write it is able to reject from that copy without forwarding it.

- Create a KV2 key in one create-only write that carries usage, description and tags, instead of writing the record and reading it back to attach them.
- Pause with jittered backoff before re-reading after a lost check-and-set write, and allow five attempts instead of three, in both backends.
- Remember for five seconds what this client last wrote or deleted at each record and re-read an answer that is older. The last answer is returned once the attempts are spent, so this only delays a read.
- Retry a Transit key delete that is refused because the deletion switch is not visible yet.

* docs(kms): describe running the Vault backends against OpenBao

* fix(kms): keep the remembered write version from moving backwards

Two writes of one record by the same client can have their acknowledgements processed out of order. Recording the lower version last made it the floor again, so a read served from that older version was accepted. The marker is now updated atomically and only raised within a record's lifetime; a write after this client's own delete starts the count again.
2026-11-14 06:59:29 +08:00
overtrue e97dc74d93 feat(gateway): serve GetBucketLocation on both stacks
Route the operation through the owned use case and shared authorization.
The tests cover two bucket names and a missing bucket on both stacks.

Validation on 20ea63e27: both clippy configurations, targeted nextest
(113 passed), and test wiring. Bypassing location authorization made the
gateway refusal matrix fail for anonymous and no-policy callers. The main
legacy comparison passed. Non-default regions were not verified.
2026-11-14 05:21:23 +08:00
overtrue e83b6815ed feat(gateway): serve DeleteBucket on both stacks
Share the use case and authorization across both edges. Preserve the
force-delete header rules and operation accounting.

Validation on 20ea63e27: both clippy configurations, targeted nextest
(113 passed), test wiring and main legacy comparison. The force-delete table
covers eight refusals and six successful cases; additional tests cover header
precedence and anonymous invalid input. Bypassing DeleteBucket authorization
made the gateway refusal matrix fail for anonymous and no-policy callers;
bypassing ForceDeleteBucket made the false-header authorization test fail.
Site replication and multi-node deletion were not verified.
2026-11-14 05:21:23 +08:00
overtrue 20ea63e27e feat(gateway): serve bucket CORS mutations
Route PutBucketCors and DeleteBucketCors through owned use cases and shared authorization, preserving audit, storage, and legacy edge behavior.

Coverage includes eight refusal and two root matrix scenarios per stack, a wrong-resource refusal, missing-context refusal, and CORS persistence cases. The scoped suite passed 125 tests on 05554bee0. Bypassing Put or Delete authorization failed the gateway refusal matrix; skipping each storage mutation failed the CORS persistence test; allowing a missing context failed the access unit test.

Not verified: full workspace CI and the missing-bucket plus invalid-configuration error ordering. The delete audit status remains 200 while the response is 204.
2026-11-14 04:00:05 +08:00
唐小鸭 a984f42b0b fix(replication): stop re-sending existing objects every scan cycle (#9412)
* fix(replication): stop re-sending existing objects every scan cycle

Existing objects on a site-replication source were re-queued and
re-sent on every scanner cycle, so the replica kept rewriting the same
versions and its reported bucket size grew while the object count stayed
flat.

Two defects combined:

- The per-target resync stamp was computed by the worker but never
  written back to the source object, so the resync decision kept
  returning "replicate" for every object older than the reset date. The
  status writeback now persists the stamp under both internal metadata
  prefixes, and a successful full-object send of an existing object is
  stamped as well.
- The target HEAD only reported the tag count, so the tag comparison
  always saw a difference for tagged objects and fell back to a full
  re-send. The replication HEAD now sends
  x-amz-tagging-directive: ACCESS and the server answers with the tag
  set under the same authorization as the tag count. Targets that do not
  return the tag set still compare as different, which costs one extra
  send instead of a loop.

Also drop replicate_all_stat_options, which built the directive but was
never passed to the HEAD call.

Refs #9354

* test(replication): use relative paths in the resync stamp test
2026-11-14 03:59:46 +08:00
overtrue f9f52f9fad fix(app): preserve stored entity tag spellings
Read stored entity tags with the existing legacy spelling rules before
constructing gateway values. Keep the original control-character coverage.
This prepares the shared helper without adding an operation caller.

Tests: four focused tests passed on 05554bee0, covering eleven spellings,
weak empty tags, control characters, and invalid header values. The table
covers seven malformed or boundary spellings and four ordinary spellings.

Mutations: weak, quotes, bare weak prefix, nested quotes and plain values
failed the spelling table; control characters failed the preservation and
header tests; empty weak tags failed the weak-tag test; removing the version
header failed the header test.

Not verified: operation-level wire responses and full workspace tests.
2026-11-14 03:50:33 +08:00
overtrue af93bf4663 feat(auth): share write-path authorization checks
Share replication header, write ETag, and staged multipart authorization across request forms, preserving the existing decisions and marker cleanup.

The parity table covers eight denials and six allowed cases. Mutations of each authorization call, replication marker and header source, ETag header source, and staged marker cleanup on success and failure all failed the parity test.

Tests and both Clippy configurations passed on 05554bee0. The gateway handlers are not included in this increment. The script test suite did not pass locally: four unchanged scanner fixture tests failed twice with expired fixture deadlines.
2026-11-14 03:43:04 +08:00
clangenb 4db694f1c4 docs(readme): add Docker Swarm install via the SwarmCLI rustfs chart (#9405)
* docs: add Docker Swarm with the SwarmCLI chart to the README quickstart

Option 7 links to the Docker Swarm guide on docs.rustfs.com and to the
community rustfs chart, noting that Eldara Tech maintains both.

* docs: point README Option 7 at the SwarmCLI chart guide's new path

The docs guide moved from Container to Cloud Native as SwarmCLI Chart.

* docs: name the SwarmCLI chart's key features in README Option 7

Secrets, versioned upgrades and rollbacks, Traefik HTTPS; and that its
Console is off and rustfsadmin refused, unlike Accessing RustFS below.

* docs: call the SwarmCLI chart open-source rather than community in README

It is maintained by Eldara Tech, which 'community' contradicted.

* docs: add the SwarmCLI chart's distributed mode to README Option 7

The chart guide now covers distributed, erasure-coded clusters as well
as a single-node service, so Option 7 no longer says single-node only.
2026-11-13 14:53:55 +00:00
Adrián Pérez 0e8fb73e57 perf(lifecycle): skip immediate-expiry lookup without lifecycle rules (#9404)
After every successful write, enqueue_immediate_expiry took the bucket
metadata-transaction read lock and read the bucket incarnation before
checking the cached bucket metadata that decides the outcome. A cached
entry without any lifecycle document can never enqueue an expiry.

Return early in that case. Buckets with lifecycle rules, unreadable
lifecycle documents, a pending creation commit or no cached entry keep
the authoritative path.

Signed-off-by: AdrianPerez3 <70107702+AdrianPerez3@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 14:52:54 +00:00
Hauser Zhi 05554bee00 chore(deps): clean up unused dependency declarations (#9411)
Move test helpers to dev-dependencies and clean unused build
requirements and workspace metadata.

Use profiling compatibility entrypoints for probe-free crates and
verify the application's hotpath, allocation, and CPU feature graphs.

Validate the affected libraries, FTPS/SFTP test targets, and 1729
existing library tests.

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-14 02:04:31 +08:00
Hauser Zhi 8d5faa5750 fix(ecstore): persist restartable format bootstrap authority (#9359)
* fix(ecstore): persist restartable format bootstrap authority

Persist all-drive creator plans before format publication and resume exact deployment and drive slots after interrupted fresh formation. Consume authority durably before startup publication and validate regular control files on full and streamed reads.

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

* refactor(ecstore): finalize format bootstrap once

Order bootstrap retirement before initialized identity publication, preserve established expansion preflight repair, and require followers to observe committed topology and complete identities.

Publish bootstrap controls through one authenticated atomic RPC on the dedicated fsync lane. Keep cancellation-safe cache ownership in the native operation and retain interoperable replacement healing.

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

* fix(ecstore): fence anchored format publication retries

Select the durable first-slot plan before fanout and complete immutable anchored plans across retries. Retain physical-root namespace ownership through native publication, retirement and cache invalidation, rejecting conflicting or retired control records.

Reuse main's unary RPC lifecycle recorder for validated outcomes and exact request, byte and cancellation accounting.

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

* fix(test): align Windows and test-util compilation gates

Match physical publication-hook tests to their non-Windows provider. Compile pool-capacity overrides with their test-util consumers, and keep alias-list mutation inside the Unix branch.

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

* test(ecstore): target native format publication paths

Co-authored-by: houseme <4829346+houseme@users.noreply.github.com>

* style(rpc): format merged request imports

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
Co-authored-by: Chris An <anzhengchao@gmail.com>
Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: houseme <4829346+houseme@users.noreply.github.com>
2026-11-14 01:04:03 +08:00
Hauser Zhi a9f308b075 test(ilm): stabilize manual transition accounting and pagination (#9409)
* test(ilm): account for completed immediate transitions

PUT and lifecycle configuration updates can enqueue transitions before a manual scan. Assert complete per-object accounting and verify a repeated scan skips the committed transition without duplicating the remote object or changing GET content.

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

* test(ilm): stabilize continuation eligibility across restart

Wait for configuration-triggered transitions to commit before testing opaque continuation tokens. Assert both pages skip exactly one completed object, never enqueue work and preserve the two remote objects across restart.

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

---------

Co-authored-by: zhi <qiuzgang@gmail.com>
Co-authored-by: heihutu <heihutu@gmail.com>
2026-11-14 01:02:11 +08:00
Adrián Pérez 2b0d74027a fix(ecstore): keep delete activation off the metadata read lane (#9402)
Strict recoverable-delete activation renamed the prepared transaction
directory on the disk's single-worker foreground lane, which also serves
metadata reads, and then queued its directory fsyncs as a separate
fsync-lane job. A stalled activation rename blocked unrelated metadata
reads on the same disk.

Run the rename, the fsync of the pinned object directory and, for a
missing original, the ancestor fsyncs in one fsync-lane closure. The set
and order of fsyncs are unchanged; relaxed and none modes keep the
previous rename path.

Signed-off-by: AdrianPerez3 <70107702+AdrianPerez3@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 14:51:38 +00:00
Hauser Zhi 964cb463a2 chore(deps): refresh Prost and WebPKI dependencies (#9392)
* chore(deps): refresh Prost and WebPKI dependencies

Run cargo update --verbose and cargo upgrade --verbose twice from main.
Upgrade the Prost family to 0.14.6 and rustls-webpki to 0.103.17.

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

* fix(ci): document shard buffer unsafe allowance

Document the arena block validity and exclusivity contract beside the
unsafe_code allowance to satisfy the existing guard.

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

* test: avoid typo false positive in PUT body chunks

Use hell and o as fixture chunks that concatenate to hello.

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

* chore(deps): upgrade rustfs-erasure-codec to 9.1.0

Run cargo update --verbose and cargo upgrade --verbose again.
Resolve rustfs-erasure-codec 9.1.0 and refresh the workspace lockfile.

Validate the integrated legacy GET producer stack fix with all 28
reported scenarios at a 2 MiB stack in both nextest profiles, plus
codec compatibility cases and the producer future-size regression.

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

* test(storage): follow moved request denial audit calls

Inspect both legacy access and owned object authorization production
sources when checking request-level denial audit wiring.

Add regression coverage for a moved call, removal of that call, and
audit calls confined to test code.

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-13 14:15:42 +00:00
cxymds ef6af77026 feat(heal): add bounded MRF management and streaming audits (#9399)
* feat(heal): add bounded MRF management and streaming audits

Publish lightweight responsibility summaries and expose authenticated, identity-bound cluster administration without reading object payloads. Stream audit-only reads while retaining staged verified bytes and full target readback for migration.

* test(admin): keep MRF coverage within gateway boundaries

Exercise owned MRF handlers through the shared admin test seam and keep wire-level authentication assertions in the router tests, without introducing another direct s3s consumer.

* test(e2e): complete MRF lifecycle lock fixture RPC

* docs: clarify integrity job resume refusals

Explain that a failed lock acquisition does not prove a live worker, and require job-status reconciliation before retrying an unknown request outcome.

* test(admin): include MRF cluster routes in route matrix

Keep the exhaustive admin route matrix aligned with the four registered cluster management endpoints, including the concrete node and responsibility ID probe.
2026-11-13 23:03:02 +08:00
Hauser Zhi 707694c097 fix(ecstore): make retired part settlement idempotent (#9393)
* fix(ecstore): make retired part settlement idempotent

Resolve a failed source admission against the canonical transaction while
retaining SourceRW ownership. Treat proven absence as already settled when
cached directory descriptors still refer to an upload retired into trash.

Cover a real pinned part transaction through certified Abort, existing closed
transactions and dangling aliases. Preserve active settlement barriers and
rooted no-follow path validation.

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

* test(e2e): bound offline OPA fixture future stack usage

Construct offline storage futures in a separate noninlined frame before
boxing them. Keep the bucket-tag fixture within the normal test thread
stack while retaining real metadata writes and authorization assertions.

The affected debug test and the full STS/OPA module pass with a 2 MiB
thread stack after the original CI smoke stack overflow.

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

* test(e2e): isolate OPA contract on a dedicated stack

Run the bucket-tag OPA contract on a dedicated 32 MiB thread with a current-thread Tokio runtime. Nested ECStore initialization poll frames can overflow the default test stack even when the outer future is boxed.

Remove the superseded future-boxing helper. Validate all eight STS/OPA tests and targeted runs with 1 MiB and 512 KiB entry stacks on Linux ARM64, plus all-target Clippy and formatting checks.

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-13 08:25:50 +00:00
Hauser Zhi f621f28d01 fix(lock): lengthen contended writer retries and report holders (#9390)
* fix(lock): extend contended writer retries within caller budget

Keep the initial probe, shared locks and batch waits at their existing peer limit. Allow later exclusive contention rounds to use a bounded longer wait so read holders outlasting one short round do not repeatedly erase writer progress. Preserve the caller deadline, quorum and grant cleanup, and cover the original failure with real LocalClient grants.

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

* feat(admin): expose physical holder counts in top locks

Serialize the node-local physical holder count from the existing fast-lock snapshot for each resource/version/mode/owner cohort. Keep row totals and lease-metadata validation, and cover repeated owners, stale leases and the actual JSON field.

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

* docs(admin): clarify node-local holder sampling

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-13 07:23:24 +00:00
overtrue d57e781375 feat(gateway): serve the policy, status and ACL reads on the gateway stack
GetBucketPolicy, GetBucketPolicyStatus and GetBucketAcl are served by the
gateway stack and by the legacy stack through one owned use case each. The
legacy access hooks call authorize_bucket_request, the function the gateway
edge calls; the owner's bypass of a bucket-policy Deny for GetBucketPolicy stays
in the shared authorization core. BucketAcl gets its use case in
bucket_usecase/acl.rs: the answer (one owner, full control, a grantee carrying
no identity) is unchanged.

Not built: GetBucketNotificationConfiguration, the four mutations and
PutBucketAcl (they wait for shared helpers).

Removed code: build_get_bucket_acl_output in storage/s3_api/acl.rs, replaced by
the use case.

Removed tests: test_build_get_bucket_acl_output_contains_full_control_grant_and_owner,
covered by the_gateway_stack_answers_the_bucket_acl and
the_legacy_stack_answers_the_bucket_acl (one owner, full control, grantee with
no id and no display name, NoSuchBucket for a missing bucket) in
tests/embedded_gateway_stack_test/bucket_access.rs.

Tests: refusal-matrix rows for the three reads on both stacks; NoSuchBucketPolicy,
the verbatim policy document, the owner reading a policy that denies everyone,
IsPublic following the stored policy, and the ACL answer, on both stacks;
use-case tests ported to the owned signatures.

Mutations: the gateway authorize answering Ok(()) in each of the three reads
turns that operation's anonymous and no-policy rows of the refusal matrix red.

Legacy answers compared with main: see the previous commit (40 rows, identical,
including the missing content-type of the stored-policy answer).
2026-11-13 20:32:56 +08:00
overtrue da07ad6a08 feat(gateway): serve GetBucketVersioning on the gateway stack
GetBucketVersioning is served by the gateway stack, and by the legacy stack
through the same owned use case (gateway input and output types). The legacy
access hook now calls authorize_bucket_request, the function the gateway edge
calls. The stored status is carried verbatim as the gateway status enumeration,
so a stored value is never dropped. As before, MFADelete is not answered.

Not built: PutBucketVersioning (it waits for the shared bucket-configuration
mutation wrapper and the owned audit call).

Tests: refusal-matrix row on both stacks (anonymous and a user without a policy
are refused, root is served and counted once); GetBucketVersioning answers every
stored bucket name the SDK reaches (a-s3alias, sthree-x, x--ol-s3), a stored
Enabled status, NoSuchBucket for a missing bucket, and the 400 InvalidBucketName
both stacks give xn--abc, on both stacks; the ported use-case test.
Differential cases: an unconfigured and a suspended bucket.

Mutations: the gateway authorize answering Ok(()) turns the anonymous and
no-policy rows of the refusal matrix red; dropping the status from the use case
turns the stored-status assertion red (left None, right Enabled).

Legacy answers compared with main (status, headers and body; the SDK output for
successes): 40 rows, for plain-bucket, sthree-x, a-s3alias, x--ol-s3 and a
missing bucket, each unconfigured and configured, for GetBucketVersioning and
the three reads of the next commit. All identical.
2026-11-13 20:32:56 +08:00
overtrue 17081a6d23 feat(server): serve the lifecycle, replication and lock reads
Batch A3 of rustfs/backlog#2765, second increment: the gateway stack serves
GetBucketLifecycleConfiguration, GetBucketReplication and
GetObjectLockConfiguration through the owned use cases from the previous
commit.

- `impl Served` for the three operations and their rows in the A3 family. Each
  `authorize` calls `authorize_bucket_request` with the action its legacy hook
  asks (GetBucketLifecycle, GetReplicationConfiguration,
  GetBucketObjectLockConfiguration) on the decoded bucket.
- The three rows of the refusal matrix. Each row stores its configuration
  through the bucket metadata first, so root is served without depending on the
  Put operations.
- The behaviour test from the previous commit also runs on the gateway stack,
  for an ordinary and a reserved-shaped bucket name.

Tests (negative / positive): refusal matrix 3 rows x 4 refused callers (12
negative, 3 positive; each is counted once under its legacy label);
gateway-stack behaviour test: NoSuchBucket 404 (3), each read's own 404 (6),
wrong-resource AccessDenied 403 (6), stored contents (6 positive).

Mutations: the three `authorize` bodies allow everything. Red:
the_refusal_matrix_holds_on_the_gateway_stack (each of the three reads serves
the anonymous and the no-policy caller), and
the_gateway_stack_answers_the_configuration_reads_as_stored (the wrong-resource
caller is served). The legacy-stack variants stay green.

Not built: the five mutations.

Not verified: the differential's gateway side (CreateBucket, PutObject and the
Put configuration operations are not all served yet; Linux reference only).
storage::access::tests::denial_exits_without_a_context_call_the_audit_function
fails on this base: the source guard looks for the force-delete exit in
access.rs, and that exit now lives in access_owned/object_misc.rs. It is not
this change.
2026-11-13 20:17:47 +08:00
overtrue d36c3595ad feat(gateway): serve CreateBucket on the gateway stack
CreateBucket is served end to end by the gateway stack; the legacy stack
serves it through the same owned use case.

- Use case: execute_create_bucket(envelope, gateway input) -> gateway
  output, on the fresh admitted task as before (the text guard names the
  new inner call). The audit entry and event come from the owned helper.
- Authorization: authorize_create_bucket in storage/access_owned/
  bucket_core.rs is the one composite hook both edges call: s3:CreateBucket
  with the body's LocationConstraint as a condition value (first decision
  without the presigned-query hoist), then PutBucketObjectLockConfiguration
  and PutBucketVersioning when object lock is requested.
- Legacy edge: record_s3_op, then through_gateway_seam.
- Gateway edge: impl Served and one ROWS entry.

Not built: no change to what CreateBucket answers; DeleteBucket and
GetBucketLocation follow in their own commits.

Tests (negatives 9, positives 8):
- embedded, both stacks: the_{gateway,legacy}_stack_creates_buckets_as_before
  (fresh, idempotent re-create, foreign and EU constraint refused, the four
  reserved name families created, xn-- refused, x--x-s3 refused by the SDK
  on the client); refusal-matrix row (anonymous, wrong secret, unknown key,
  no policy refused; root served, counted once).
- parity: owned_and_legacy_create_bucket_authorization_use_location_constraint
  gains six composite cases (location, object lock) comparing decision and
  handed-on bucket, legacy hook against owned function.
- use case: tests ported to the owned signature; empty LocationConstraint
  reads as none.
- differential: CreateBucket cases for a foreign constraint, EU and the
  reserved name families.

Mutation: Served::authorize returns Ok(()) ->
the_refusal_matrix_holds_on_the_gateway_stack red ("CreateBucket serves the
anonymous caller", "... the no policy caller").

Changed assertion: guards.rs names the inner call
execute_create_bucket_inner(envelope, input, mutation_permit) instead of
(req, mutation_permit); same check, new signature.

Metric (ledger candidate, no wire change): the legacy edge now counts every
CreateBucket call, including one its own validation refuses.

Not verified: the differential run against 1.0.5 (Linux CI).
2026-11-13 19:15:24 +08:00
overtrue db5a910b69 fix(s3-types): keep a typed cause across the s3s round trip
A typed cause now survives the s3s -> owned -> s3s round trip when the
code is unchanged. Before, an s3s error that crossed into
`rustfs_s3_types::S3Error` carried its whole self as a `LegacyCause`
wrapper, and crossing back set that wrapper as the cause, so a caller
downcasting the cause after an owned use case (a legacy edge's
diagnostics, a test asserting `StorageError::ErasureReadQuorum`) found a
wrapper. Crossing back now hands the original s3s error on and applies
the message, request id, status and headers on top; an error our side
re-coded keeps the wrapper, which shows the cause's text, as before.

Test (1 added, both directions):
`a_round_trip_hands_the_typed_cause_back_unless_the_code_changed` - an
untouched round trip is exactly the original (code, message, explicit
status, headers, typed cause); a changed message is applied with the
typed cause kept; a re-coded error keeps only the cause's text.

Mutation: always keeping the wrapper (the hand-back arm dropped) makes
the new test red.
2026-11-13 19:08:01 +08:00
overtrue 77ce76fde9 test(storage): read the force-delete denial exit where it now lives
The source-level guard that every denial exit without a context calls
audit_request_denial read only storage/access.rs. 8eb89dd54 moved
DeleteObject's decision, with its recursive-force-delete exit, into
access_owned/object_misc.rs and left the guard behind, so the guard went
red although the exit never stopped auditing. The guard now reads each
exit in the file that holds it.

Tests: the storage::access lib module, run whole: 113 passed.
Mutation: removing the audit_request_denial call from the exit in
access_owned/object_misc.rs turns the guard red with
"\"recursive_force_delete_requires_authenticated_caller\" exit does not
call audit_request_denial".
2026-11-13 18:59:43 +08:00
overtrue d645456a90 refactor(storage): carry body-sourced policy inputs in owned form
The policy inputs some hooks take from a request body are now owned
types that both request forms carry and install through
`AuthorizationRequest`, so the gateway edge no longer needs s3s DTOs:

- `RequestedObjectLockRetention { mode, retain_until }`.
- `RequestedObjectLegalHold(Option<String>)`, the status.
- `RequestedObjectTags(Vec<(String, String)>)`. It keeps only complete
  key/value pairs; those are the only tags a condition ever named.

Each type converts from its s3s DTO once, at the legacy insert site
(`From<&ObjectLockRetention>`, `From<&ObjectLockLegalHold>`,
`From<&Tagging>`). The conditions built from them are unchanged.

New trait installers: `install_requested_retention`,
`install_requested_retain_until`, `install_requested_legal_hold` and
`install_requested_object_tags`. The legacy hooks use them.

`set_requested_object_lock_retain_until` is now generic and takes an
owned `OffsetDateTime`.

`RequestEnvelope::fork_for_authorization` copies a request for one
more authorization, such as an archive member. Every field is copied,
the access phase's output included. The table publication guards stay
one shared set, so a lock retained through the copy is held for the
original's write. Anything else installed on the copy does not show on
the original.

Tests:
- A new parity test installs body inputs on both forms. The installed
  bodies, not conflicting headers, must describe the request, and an
  incomplete tag must name nothing.
- A fork test checks that the copy reads like the original and that
  what is installed on the copy stays off the original.
- The object-shape column of the decision table now runs on a forked
  envelope.
2026-11-13 18:09:11 +08:00
overtrue fa13764bb7 feat(bucket): answer lifecycle, replication and lock reads as owned
Batch A3 of rustfs/backlog#2765, first increment: GetBucketLifecycleConfiguration,
GetBucketReplication and GetObjectLockConfiguration are owned use cases
(gateway DTO in, gateway DTO out). The legacy stack serves them through
`through_gateway_seam`. Nothing is registered on the gateway stack yet; that
comes in the next commit, once the gateway error mapping answers a missing
bucket 404.

What changes:
- `app::dto_values::stored_config(&T: BucketConfigXml, parse)` is the one way a
  stored bucket configuration becomes a gateway DTO: its persisted bytes, read
  by the gateway's DTO bridge (`parse_*_dto`). A refusal is InternalError.
- `execute_get_bucket_lifecycle_configuration` and `execute_get_bucket_replication`
  take and answer gateway DTOs. `execute_get_object_lock_configuration` is new
  in `bucket_usecase/object_lock.rs`, moved from the inline legacy edge body.
  Codes and messages are unchanged.
- The legacy edges of the three reads count the operation and go through the
  seam. The input members the seam converts are `bucket` and
  `expected_bucket_owner` for each.
- The three legacy access hooks call `authorize_bucket_request` with their
  legacy action (GetBucketLifecycle, GetReplicationConfiguration,
  GetBucketObjectLockConfiguration).
- `storage/s3_compat/{lifecycle,replication}.rs`: the reverse (stored -> s3s)
  direction is no longer on the request path and is compiled only under
  `cfg(test)`, as the oracle of the parity tests below and of replication's
  existing round-trip tests. It goes, with retirement entries, when the Put
  edges cross the seam.

Tests (negative / positive):
- Legacy answer parity against main's own conversion: lifecycle (XML bytes,
  with DelMarkerExpiration, ExpiredObjectAllVersions, Transition,
  NoncurrentVersionTransition, an And/Tag filter and dates, one with a +08:00
  offset), replication (XML bytes, with DeleteReplication,
  ExistingObjectReplication, ReplicaModifications) and object lock (value; it
  holds no timestamp). 3 positive.
- dto_values: a stored configuration round-trips byte for byte through the
  bridge (1 positive); a bridge refusal is InternalError (1 negative).
- Use cases: store not initialized is InternalError for each read (3 negative;
  the replication one is ported to the owned signature).
- Embedded, legacy stack, for an ordinary bucket and a reserved-shaped one
  (`sthree-a3-stored`, `a3-empty-s3alias`): missing bucket is NoSuchBucket 404
  (3), no configuration gives each read's own 404 code (6), a caller allowed on
  other buckets only is AccessDenied 403 (6), the stored contents are answered
  (6 positive). 15 negative, 6 positive.
- Differential (`scenarios/extra/bucket_replication_lifecycle.rs`): lifecycle
  with every member and a dated rule on a reserved-shaped bucket, lock reads
  before and after a Years rule, absent-configuration reads.

Mutations (run on this tree before the rebase onto ea56aa923):
- M1, `stored_config` rewrites a stored member (WARM -> COLD) before the
  bridge: red in s3_compat::lifecycle::tests::the_legacy_answer_through_the_seam_is_the_answer_of_the_reverse_direction,
  dto_values::tests::a_stored_configuration_is_answered_with_every_stored_member,
  and embedded the_legacy_stack_answers_the_configuration_reads_as_stored.
- M2, the GetBucketLifecycleConfiguration legacy hook allows everything: red in
  embedded the_legacy_stack_answers_the_configuration_reads_as_stored (the
  wrong-resource caller was served).

Not built: the gateway edge (`impl Served`, rows, refusal-matrix rows, the
gateway-stack variant of the behaviour test), the five mutations.

Not verified: the differential (needs the Linux reference binary, so it is
CI's); the e2e_test crate built only by clippy.
2026-11-13 17:57:35 +08:00
overtrue c221fb62a3 test(storage): audit each mutation without an event at exactly one place
The audit coverage guard required the legacy wrapper for every mutating
operation without a notification event. A migrated operation writes its
audit entry in the use case instead, so both stacks record the same entry,
and its legacy edge drops the wrapper. The guard now accepts exactly one
audit site per operation: the legacy wrapper in ecfs.rs / legacy_edge,
or the owned call under src/app. Both sites at once or neither is a failure.
Calls are matched with whitespace ignored, so rustfmt wrapping and trailing
commas still match.

Accepted owned shapes under src/app:
  audit_only_operation(envelope, S3Operation::X, ...)
  OperationHelper::audit_only_from_view(&envelope.audit_view(), S3Operation::X)

SourceSet gains count_ignoring_whitespace for this.

Tests: the production guard (all 22 operations, still on the legacy
wrapper); fixtures accepted (legacy only, owned helper wrapped by rustfmt
with a trailing comma, owned envelope wrapper wrapped); fixtures refused
(neither, legacy plus each owned form, an owned call only under #[cfg(test)],
a wrapper and an owned call for UploadPartCopy, which must not count for
UploadPart). Negatives 6, positives 4.

Mutation: owned helper needle renamed so it never matches; both fixture
tests went red (the_guard_accepts_exactly_one_audit_place,
the_guard_refuses_an_operation_audited_nowhere_or_twice), the production
guard stayed green. An earlier run of the fixtures caught a needle that
missed rustfmt's trailing comma; fixed before this commit.

Not verified: nothing beyond the audit_coverage_tests module was run.
2026-11-13 17:36:03 +08:00
overtrue ad94f6914a feat(gateway): answer RustFS refusal facts in their legacy form
The gateway stack's one error mapping now answers every code the
gateway refuses without a context (its is_contextual set: NoSuchKey,
NoSuchVersion, NoSuchBucket, PermanentRedirect, TemporaryRedirect,
NotModified, AuthorizationHeaderMalformed, MethodNotAllowed,
BucketAlreadyOwnedByYou, AccessForbidden) and InvalidRange through
the gateway's LegacyRustfsRefusal, stating the facts the error's own
response headers carry:
- NotModified: ETag, Last-Modified, Cache-Control, Content-Location,
  Expires, Vary and the evaluated x-amz-version-id;
- InvalidRange: Content-Range: bytes */<length>;
- NoSuchKey / MethodNotAllowed on a delete marker:
  x-amz-delete-marker: true, x-amz-version-id, Last-Modified.
s3s takes no part. A fact a code may not state, an unreadable or
repeated fact, or a refusal the gateway cannot state is answered 500
InternalError rather than sent with a member missing. Before this, each
of these codes failed the gateway's context check, so for example
HeadBucket on a missing bucket could not answer NoSuchBucket on the
gateway stack. The list is pinned against the gateway's own behaviour
in both directions.

PermanentRedirect and TemporaryRedirect are answered 500: the legacy
refusal states only 4xx, 5xx and the 304 of NotModified. RustFS raises
neither.

Adds crate::app::dto_values::stored_etag(&str) -> ETag, the one
conversion of a stored entity tag for every answer that carries one:
a tag the gateway reader accepts is read as it reads it, any other
(empty, a control character) is carried byte for byte
(ETag::from_stored). Nothing calls it yet; batch C's reads and B2's
listings are its first callers.

Not built: no operation of batch C is registered here; the
embedded-server tests of these answers come with HeadObject.

Tests: 12 new in gateway_handlers::error with 18 refused rows (facts a
code may not state, unreadable or incomplete facts, redirects, a hidden
missing key) and the list checked against the gateway both ways, versus
15 answered rows; 2 in dto_values (1 carried-verbatim, 1 spellings).

Changed assertions: every_header_of_the_closed_set_is_carried uses
SlowDown instead of InvalidRange, because InvalidRange is now answered
in the legacy form; it still covers every header of the ordinary
closed set.

Mutations: run right after this commit lands, reported on
rustfs/backlog#2767; a mutation that stays green is fixed by the next
commit.

Refs: rustfs/backlog#2767
2026-11-13 17:24:44 +08:00
overtrue 190f3686f4 refactor(storage): own the object-listing authorization for both edges
Move the listing authorization of batch B2 into
`storage/access_owned/listing_multipart.rs`, generic over
`AuthorizationRequest`, so the legacy access hooks and the gateway edge
call one copy:

- `authorize_bucket_listing` (ListObjects, ListObjectsV2,
  ListObjectVersions, the metadata listings): the bucket on `ReqInfo`, the
  listing action, `ListBucketVersions` as well for `include-deleted: true`
  on a `ListBucket` listing, then the table snapshot. The repeated-query
  `InvalidRequest` and the anonymous `ListBucket` fallback stay inside the
  policy decision.
- `authorize_list_objects_v2`: the on-demand migration generation captured
  before the decision and installed after an allow.
- `prepare_table_data_plane_list_access` and its fingerprint/cursor-key
  helpers move here unchanged, now generic; the snapshot reaches the use
  case through the new `AuthorizationRequest::install_table_list_access`.

The ListObjects, ListObjectsV2 and ListObjectVersions hooks reduce to one
call each; ListMultipartUploads keeps its generation guard and calls the
moved snapshot. Same actions, same order, same refusals.

Tests (1 added, 1 extended; negatives in the extended table outnumber the
allows): `table_list_access_reaches_the_use_case_from_either_edge`; the
include-deleted table (`include_deleted_listing_enforces_version_permissions`)
now decides every case on an envelope too and requires the same answer.

Mutations: dropping the `include-deleted` follow-up makes the extended
table red; an envelope installer that installs nothing makes the new test
red.

Not built here: the gateway rows and the owned use cases (they wait for
the gateway re-pin).

Verified: the touched tests (19, listing/table access/metadata route)
ran on f33271a74 (before re-pin 1); feature and default clippy
--all-targets ran there too; feature clippy --all-targets ran again on
941fb4fc1, the final base.
2026-11-13 17:13:13 +08:00
overtrue 941fb4fc11 refactor(access): one owned copy-source authorization for both copies
CopyObject and UploadPartCopy authorized their copy source with two
identical blocks in their S3Access hooks. Both hooks now call
`access_owned::object_commit::authorize_copy_source`, generic over
`AuthorizationRequest`, which the gateway stack's `Served::authorize`
for both operations will call too (batch E1, rustfs/backlog#2769). The
order is the hooks' order, unchanged: an access-point or Outposts ARN
source is NotImplemented before any policy is read; the source is
recorded for the `x-amz-copy-source` condition; its bucket incarnation
is captured; reading it is authorized (s3:GetObjectVersion when a
version is named); a failed capture is surfaced only after the allow,
and the incarnation is handed on. The destination is decided afterwards
by each hook, as before. `AuthorizationRequest` gains the two installers
the shape needs, implemented for `S3Request` and `RequestEnvelope`.

Measurement for the batch (recorded here as the coordinator asked):
none of the three E1 operations commits a 200 before its work ends, so
the gateway edges will answer with `Resp::new`, not `Resp::commit`.
The pinned 1.0.5 reference binary could not be run on this host (the
asset is Linux x86-64 only and no container runtime was usable), so the
current legacy stack was measured instead: the debug binary at e8847f6f1,
default stack, on 127.0.0.1, driven by `curl --aws-sigv4`:
- CompleteMultipartUpload with a wrong part ETag: 400 InvalidPart with
  Content-Length; success: 200 with Content-Length, not chunked.
- CopyObject, missing source: 404 NoSuchKey; success: 200 with
  Content-Length.
- UploadPartCopy, missing source: 404 NoSuchKey; range beyond the
  source: 416 InvalidRange; success: 200 with Content-Length.
The 1.0.5 source agrees (tag 1.0.5, s3s 5761ddfe): s3s writes a
keep-alive body only for CompleteMultipartUpload and only when the
output's `future` member is set (crates/s3s/src/ops/multipart.rs:27);
RustFS never sets it, and CopyObject and UploadPartCopy have no such
path.

Not built: the destination half of either hook, the gateway edges
(they arrive with each operation's own increment), and the copy-source
read guard (task H's generic form is used as is).

Lines outside tests: +105 / -59 (access.rs, envelope.rs, the new
access_owned/object_commit.rs).

Tests (6 negative cases, 2 positive in the parity table; the hook test
has 2 negative cases and 1 control per operation): copy-source parity
on both edges, comparing decision,
recorded source, handed-on incarnation and ReqInfo for an ARN source,
a source without a read policy, a named version under s3:GetObject,
a deny with a failed capture, a failed capture after an allow, a
missing ReqInfo, and the two allows; and both legacy hooks refuse a
denied source and an ARN source without ReqInfo ever naming the
destination.

Mutations (two grouped runs of the two new tests, each reverted):
- ARN source answered Ok: parity "an ARN source is NotImplemented..."
  and hook "CopyObject: a denied source"/ARN case red.
- source decision skipped: parity "a source without a read policy..."
  and "a deny wins over a failed incarnation capture" red.
- version swap dropped (always s3:GetObject): parity "a named version
  needs s3:GetObjectVersion" red.
- capture failure surfaced before the decision: parity "a deny wins
  over a failed incarnation capture" and "a failed incarnation capture
  is surfaced after the allow" red.
- destination check before the source (CopyObject hook): hook
  "CopyObject: a denied source" red.

Not verified: UploadPartCopy's source-before-destination order is not
distinguishable by an answer on the legacy hook (both halves refuse
AccessDenied); it is pinned on the gateway edge with that operation.
The gateway stack is unchanged by this commit.
2026-11-13 16:58:20 +08:00
overtrue 0e44453639 refactor(helper): make run_owned_mutation generic over its result
`run_owned_mutation` owned a mutation on its own task only when the
mutation answered an s3s `S3Response`. The owned use cases of batch E1
(CompleteMultipartUpload first) answer a gateway DTO with the owned
error type, so the helper is now generic over the result:
`run_owned_mutation<R, E, F>(operation: F) -> Result<R, E>` where
`F: Future<Output = Result<R, E>> + Send + 'static`, `R: Send + 'static`
and `E: From<rustfs_s3_types::S3Error> + Send + 'static`. A lost owner
task is still InternalError "object mutation owner task failed"; the
s3s error is reached through the existing `From` conversion, so the
legacy callers (DeleteObject, DeleteObjects, CompleteMultipartUpload)
compile and answer unchanged. The task-locals it carries into the
spawned task (Keystone credentials, the S3 HTTP operation context) are
unchanged.

Not built: no new caller in this commit; the owned
CompleteMultipartUpload use case is the first.

Tests: none added; the existing callers' tests ran unchanged (71 run
in the touched modules, all passed). Not mutation-checked: a pure
signature generalisation with no new assertion.
2026-11-13 16:58:19 +08:00
overtrue 0fde0f14a0 Revert "fix(ecstore): isolate unavailable local drives during startup (#9353)"
This reverts commit f6d64bc1f.

The change was merged outside the merge queue, so the full end-to-end
merge gate never ran on it. On main that gate fails 25 multi-node
cluster tests since f6d64bc1f (distributed_startup_regression_test,
inline_fast_path_cluster_test, heal_erasure_disk_rebuild_test,
tier_stats_cluster_test, upgrade_compatibility_test): every node answers
503 and never becomes ready, logging "Local endpoint has no format on
the system filesystem; restore its data mount" for its fresh data
directories. The run before it (c43e415b0) passed all of them.

Reverting restores the previous startup behaviour so the change can be
re-landed through the queue together with a decision on how fresh
URL-style clusters on a system filesystem (and the cluster test
harness) are meant to start.

The stack-overflow fix c83f47871 in set_disk/ops/object.rs is kept.
2026-11-13 16:27:06 +08:00
overtrue aa5f145983 build: re-pin the gateway to 1bbef575
Brings rustfs/gateway#1613 (listing members a stored entry may lack are
written as no element), #1614 (ListMultipartUploads url encoding under
the RustFS profile) and #1616 (PutObject and UploadPart carry the legacy
content length). No RustFS caller uses the changed converters yet.
2026-11-13 16:06:54 +08:00
overtrue ea56aa9238 refactor(storage): authorize bucket configuration changes on both edges
`authorize_bucket_config_mutation(server_ctx, req, bucket, action)` is
now generic over `AuthorizationRequest`, so the legacy hooks and the
gateway edge run the same shape. The shape records the bucket on
`ReqInfo` and snapshots the bucket incarnation under the lifecycle
namespace read lock before the decision. It surfaces a snapshot failure
only after an Allow, and on Allow it installs the snapshot (new trait
installer `install_bucket_config_mutation`) for
`bucket_config_mutation_incarnation`.

The 22 legacy hooks of the shape now call it, with no other change:

- Delete: BucketCors, BucketEncryption, BucketLifecycle, BucketPolicy,
  BucketReplication, BucketTagging, BucketWebsite and
  PublicAccessBlock.
- Put: BucketAccelerateConfiguration, BucketCors, BucketEncryption,
  BucketLifecycleConfiguration, BucketLogging,
  BucketNotificationConfiguration, BucketPolicy, BucketReplication,
  BucketRequestPayment, BucketTagging, BucketVersioning, BucketWebsite,
  ObjectLockConfiguration and PublicAccessBlock.

DeleteBucketTagging keeps its `with_bucket_tag_deletion` scope at the
call site.

Tests: the decision fixture of the owned-versus-legacy parity tests is
now one shared function. A new parity test runs eight cases through
both request forms and compares the decision and the snapshot handed
on. Three are allowed: IAM user, anonymous via bucket policy, owner.
Five are refused: wrong resource, no policy for the action, anonymous
on a private bucket, anonymous on a missing bucket, owner on a missing
bucket.

Not built here: the gateway edges of these operations (batches A1-A4).
2026-11-13 15:51:23 +08:00
overtrue 8eb89dd542 refactor(storage): decide DeleteObject in one owned function
DeleteObject's composite access decision moves out of the legacy S3Access
hook into access_owned::object_misc::authorize_delete_object, generic over
AuthorizationRequest, so the legacy hook and the gateway edge call the same
code. The legacy hook loads the bucket generation, calls it, and installs
the guard it returns; its order and answers do not change: NoSuchBucket
before policy, DeleteObject[Version] for the version storage deletes (the
source-version header for a replica delete), ForceDeleteObject, the
authenticated-caller rule for a recursive force delete, and
BypassGovernanceRetention.

Not built here: the gateway edge of DeleteObject and its use case on the
owned DTOs (they route the legacy body through the seam and wait for the
re-pin).

Tests (access_owned/object_misc_test.rs): one table test runs both
request forms (s3s request and owned envelope) through the decision and
compares the answer and the state handed on (ReqInfo bucket, key, version;
guard ready or failed): 5 refused (missing bucket before policy,
anonymous, caller without a policy, no caller installed, invalid
force-delete value) and 3 allowed (replica delete naming no version gets
its source version, any other delete ignores that header, an unavailable
generation is handed on as a failed guard).

Mutations (each run collects every failing case):
- NoSuchBucket check removed, invalid force-delete read as false, replica
  version swap removed (one build): the missing-bucket, invalid
  force-delete and replica cases went red, in both request forms
- policy decision skipped: the anonymous and no-policy cases went red,
  in both request forms

Verified locally: clippy -D warnings with and without gateway-stack (on
the base before the last rebase, which touched none of these files); 64
delete-related lib tests (app::object::delete, the lifecycle delete tests,
storage::access delete tests) passed, and the parity test passed in its
own run.

Not mutation-checked here: ForceDeleteObject, the authenticated-caller rule
and BypassGovernanceRetention need a caller a policy partly allows; the
existing use-case tests cover the predicate.
2026-11-13 15:26:49 +08:00
overtrue 4a1d542f2d build: re-pin the gateway to 66193a80 and map seam name refusals once
The pin carries floor-only bucket names across the s3s seam and a typed
ConversionError::name_kind (rustfs/gateway#1610), so HeadBucket's legacy
edge goes through the generated conversion again. seam_error now lives in
crate::app::dto_values and ecfs.rs delegates to it: a bucket name below
the floor stays a server fault, because s3s admits only names the floor
accepts; any other refusal is a server fault as before. handler_error
carries the four stored headers the pin adds to ErrorHeader.

One legacy difference is observable: a key the seam refuses (empty,
longer than 1024 bytes, NUL) is answered 400 InvalidArgument with the
fixed message "Invalid object key", where the message text previously
came from the store or the key validator.
2026-11-13 14:30:24 +08:00
overtrue 75f53303e1 fix(storage): count an operation once, at its edge, not in the owned helper
An operation is counted once per request by its edge, after authorization
and before the use case: the gateway's blanket handler already does so, and
a migrated operation's legacy edge calls record_s3_op at the top of its
impl S3 body. OperationHelper::from_view therefore no longer counts; the
legacy constructor OperationHelper::new keeps counting exactly as before for
operations that are not migrated yet. Without this, every owned mutation
that builds its helper with from_view would count twice on the gateway stack.

Not built: no caller of from_view changes here; the first one is the owned
CreateBucket use case.

Tests (1 negative, 1 positive in one test):
only_the_legacy_helper_counts_the_operation - the owned helper counts
nothing; the legacy one counts once.

Mutation: record_s3_op(op) put back into from_view ->
only_the_legacy_helper_counts_the_operation red ("the owned helper counts
nothing").

Local gate: fmt; clippy --all-targets -D warnings with gateway-stack and in
the default build; nextest storage::helper + app::owned_audit_test, 28 passed.
2026-11-13 14:25:35 +08:00
overtrue f33271a743 test(storage): compare resource-free conditions without the clock keys
`resource_free_conditions_read_the_same_client_through_both_forms`
compared two condition maps read at different instants, so
`CurrentTime` (and, across a second boundary, `EpochTime`) differed
between the legacy and the owned read, and the test failed. Both clock
keys are now removed before the comparison. Every request-derived key
must still match, and `SourceIp` is still pinned to its expected value.

This corrects a test introduced in 9c394af48.
2026-11-13 14:04:54 +08:00
overtrue c83f47871d fix(ecstore): box the legacy GET producer read pipeline
Since eca95f297 (#9304) every GET through the legacy duplex pipeline
built `run_legacy_producer_segment` futures that embedded the whole
`get_object_with_fileinfo` read future inline, wrapped again in an
`async move` block and the shard-emitter scope. `get_object_reader`
builds one such producer per downstream arm and per segment, so its
debug poll frame grew to 641,888 bytes. Any test that read an object
back through a real store on a 2 MiB thread overflowed the stack and
aborted (28 workspace tests and one e2e test on main, e.g.
rustfs-heal mrf_partial_write_test, heal_integration_test, and
rustfs app::object::internal_put::tests).

The read future is now boxed inside `run_legacy_producer_segment`, so
the producer future is pointer-sized. No behaviour change.

Measured (debug, aarch64-apple-darwin, line-tables-only):
- run_legacy_producer_segment future: 110,200 -> 320 bytes
- <SetDisks as ObjectIO>::get_object_reader poll frame:
  641,888 -> 202,352 bytes (prologue stack allocation)

Regression test (negative): set_disk::ops::object::
legacy_producer_stack_tests::legacy_producer_future_keeps_the_read_pipeline_off_the_stack
asserts the producer future is at most 1024 bytes. Mutation: removing
the Box::pin makes it fail with "got 110200 bytes".

Verified locally: the 7 previously aborting rustfs-heal tests pass;
the rustfs lib tests that aborted on main (app::object::internal_put,
on_demand_migration_put, put sse_c, owned_authorization_test,
storage::access, object_zip_download, directory_index, data_usage
snapshot gating, snowball extract) pass, 94 of 94 selected.
clippy -p rustfs-ecstore --all-targets reports only the existing
unused PoolSpaceForTest items in store/rebalance.rs, not this change.
Not run locally: the full workspace, the e2e test
sts_query_compat_test::test_bucket_tags_opa_contract, and release-build
frame sizes.
2026-11-13 13:52:41 +08:00
Hauser Zhi f6d64bc1fb fix(ecstore): isolate unavailable local drives during startup (#9353)
* fix(ecstore): isolate unavailable local drives during startup

Keep missing local endpoints in their configured slots and initialize healthy
local drives before applying the existing format and service quorums.
Protect unformatted Linux URL endpoints from writes to the system filesystem,
validate legacy admission, and retry missing local slots during format waits.

Refs rustfs/rustfs#9350
Refs rustfs/backlog#3174

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

* refactor(ecstore): prepare local drives before registry publication

Prepare local disks with bounded concurrency outside inventory locks and publish validated batches under per-instance writer coordination. Preserve existing registrations on failed or cancelled full initialization, reuse current-root handles, and withdraw stale reopened slots.

Unify initial-format and reconnect publication, retain raw and explicit-context constructor contracts, and move filesystem queries into owned native jobs. Centralize format validation and reject special format files before startup writes.

Refs rustfs/rustfs#9350
Refs rustfs/backlog#3174

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

* chore(ecstore): tighten formatted-error ratchet after refactor

Drop the three removed runtime registration call sites from the shrink-only baseline.

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

* test: align drive fixtures with startup admission

Expect the disk-scoped missing-root error and enable the existing directory test mode for the synthetic URL-based receiver fixture.

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

* refactor(ecstore): unify local drive admission and publication

Share bounded preparation and pre-I/O membership snapshots across local
startup and retry paths, with coherent registry and topology publication.
Coalesce native startup preflight and preserve root and buffer ownership.
Keep reconnect ID caches instance-scoped and retain admitted health monitors.

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

* fix(ecstore): pin multipart index queue aliases to owner lifetime

Derive the Linux index alias from the existing identity descriptor so a
retired caller descriptor cannot redirect rebuild or reconnect queue lookup.
Retain the original descriptor assertion and cover cross-disk alias reuse.

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-13 00:04:54 -05:00
Hauser Zhi d37640fbb9 fix(grpc): record TLS setup failures and cancelled dial attempts (#9388)
* perf(protos): balance peer channels and synchronize TLS eviction

Use bounded per-peer bulk cursors and shared TLS generation reads. Keep eviction and generation removal coherent with concurrent publication, and expose opt-in bulk transport tuning with checked capacities.

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

* feat(metrics): observe internode unary request lifetimes

Record client attempts through errors and cancellation, preserve the published server-duration family, and add gated activity and completion metrics. Cache enabled instruments after recorder publication while retaining startup duration recording.

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

* test(perf): make internode gRPC experiments reproducible

Reset phase-owned settings before applying overrides, separate lifecycle experiments, and provide a bounded loopback workload with independently reported control and bulk latency.

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

* test(perf): isolate transport knobs and redact dry runs

Add single-parameter P0 presets with separate artifacts while preserving the legacy combined default. Mask credential arguments in dry-run output without changing actual dispatch, and document fleet stop barriers and measurement boundaries.

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

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

* feat(observability): qualify gRPC windows and trace shutdown

Reject stale, incomplete or maintenance-active measurement evidence using
producer timestamps and independent process identities. Preserve raw inputs,
bind evidence hashes, and exercise failure paths through the script entry point.

Record HTTP/2 graceful, child-join and TLS reloader retirement phases without
changing shared deadlines, join ownership or unclean-shutdown marker policy.
Document RPC coverage, fixed-window behavior and separate maintenance workloads.

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

* test(perf): add authenticated ReadAll and fixed-rate Ping probe

Exercise production remote-disk and signed control clients against task-owned temporary fixtures. Preserve all offered control arrivals, dispatch delay, payload validation and bounded raw request samples, with optional external measurement markers.

Register probe regressions with the default package test discovery and document its telemetry, retry and storage-acceptance boundaries.

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

* fix(perf): resolve RPC probe disks by explicit UUID

Allow a complete non-nil disk UUID mapping to be installed through the existing remote-disk client API before fixture preflight. This supports test services that register local paths instead of the probe's transport URLs, without modifying server metadata.

Validate mapping shape and assert the actual wire target in the loopback regression. Keep preflight diagnostics limited to the numeric disk-error classification.

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

* docs(perf): reseed temporary RPC fixtures after restart

Separate startup-cleaned RPC temporary files from confirmed S3 durability fixtures. Revalidate readiness and disk identity before reseeding the probe after recovery.

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

* fix(server): cancel unfinished TLS handshakes during shutdown

Cancel pre-request TLS acceptance when the listener retires so silent
peers cannot retain graceful watchers beyond the shared drain budget.
Keep established TLS/H2 response draining and original child joins intact.

Add real TCP/TLS shutdown regressions and document fresh native OTLP
observation fences and exec-confirmed diagnostic test units.

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

* perf(grpc): reuse bulk keys and fix IPv6 TLS verification

Reuse bounded per-peer slot keys and retain the existing cache identities for larger pools. Delegate custom-CA certificate names to tonic's URI parser and cover real IPv6 control/bulk TLS connections with a wrong-name rejection regression.

Classify ReadVersion failure boundaries while preserving error totals, raise the bounded raw probe budget, and align the Linux-only rename test helper with its caller's platform condition.

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

* test(grpc): keep eviction race behind cache helpers

Pause eviction on the owned TLS-generation lock and inspect the channel through the common cache API. Assert lock ordering while both mutations are queued, then retain the replacement-generation assertion after they complete.

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

* fix(grpc): load native trust and preserve mTLS client identity

Select explicit private trust or platform roots, then attach the published client identity for either mode. Build the TLS connector on the blocking pool under the existing acquisition deadline.

Cover real control/bulk TLS connections, required client authentication, private-root scope and queued configuration timeout without late connection establishment.

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

* fix(grpc): account for TLS setup failures and cancelled dials

Own explicit dial metrics from validated endpoint setup through connection completion. Record TLS preparation failures and acquisition cancellation once while keeping peer-health decisions in the connect-result branches.

Cover malformed client identity, queued configuration cancellation and successful coalesced dials, and document the metric scope.

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

---------

Co-authored-by: heihutu <heihutu@gmail.com>
Co-authored-by: zhi22915 <qiuzgang@gmail.com>
2026-11-13 00:04:41 -05:00
overtrue 9c394af489 refactor(storage): read and install authorization state on both edges
The state an access hook hands to a use case is now read and installed
through the `AuthorizationRequest` trait. Its two implementors are the
s3s request and `RequestEnvelope`, so the legacy hooks and the gateway
edge call the same functions:

- These readers are now generic over `AuthorizationRequest`:
  `apply_bucket_generation_guard`,
  `apply_copy_source_bucket_generation_guard` (both on one shared
  fence), `odm_read_generation`, `prepare_odm_read_generation`,
  `bucket_config_mutation_incarnation`,
  `replication_request_authorized`,
  `retained_table_data_plane_publication_guards`,
  `request_context_from_req`, `resource_free_condition_values`,
  `req_info_ref`, `req_info_mut`, `load_bucket_generation_from_store`
  and `SseKmsPrincipal::from_request`.
- `load_bucket_generation` and `capture_odm_read_generation` now take
  the server context explicitly. The legacy hooks pass
  `FS::server_ctx`.
- New trait accessors: request context; the bucket, pending-delete,
  copy-source and ODM generation guards; the bucket-config mutation
  snapshot.
- New trait installers: the bucket, pending-delete and ODM generation
  guards. The legacy hooks now install those guards through them.
- New: `authorize_object_request(req, bucket, key, version_id,
  action)`, the object twin of `authorize_bucket_request`, with no
  version swap. `versioned_read_action` and `versioned_tagging_action`
  become crate-visible so callers can pick the action first. The
  GetObjectAcl, PutObjectAcl, GetObjectLegalHold and GetObjectRetention
  hooks now call it.
- Removed: `request_context_from_extensions`, which had no caller left.

Each reader keeps the same answers and the same error codes and
messages.

Not built here: the bucket-configuration mutation shape, the
body-input newtypes, and the replication-only, write-ETag and
staged-part checks.

Tests: `storage/access_readers_test.rs` covers each reader through
both forms with the state present and absent (12 refusal
cases, 11 accepted or absent ones), plus the installers on the envelope. The
existing owned-versus-legacy decision table now also runs every case
through `authorize_object_request` on the envelope.
2026-11-13 12:38:19 +08:00
overtrue be2d3ca2cf refactor(storage): add one owned-authorization module per batch
Add `storage/access_owned/` with one empty module for each migration
batch stem: bucket_core, bucket_configs, bucket_access,
bucket_replication_lifecycle, object_meta, listing_multipart,
object_read, object_write, object_commit and object_misc. A batch puts
an authorization shape that only its own operations use into its own
file, so parallel batches never edit the same `mod` list. Shapes that
several batches share stay in `storage/access.rs`.

The directory is mounted as a child module of `access.rs`
(`#[path = "access_owned/mod.rs"]`), so the shapes can use the guard
state that `access.rs` keeps private without widening its visibility.
The gateway edge reaches the modules through
`storage_api::server::http::access::access_owned`, feature-gated in the
same way as `authorize_bucket_request`. The re-export carries
`#[expect(unused_imports)]` until the first batch uses it.

No behaviour change. No tests, since the modules are empty.
2026-11-13 12:38:19 +08:00
overtrue 1ce2e51358 test(server): pin legacy HeadBucket name answers as measured on main
xn--abc is refused by the edge (400) and the SDK sends nothing for a
--x-s3 name, as on main before the use case moved onto the gateway's
types (measured with an embedded-server probe on main). The corrected
test was not run locally: the build host had no disk for it.
2026-11-13 12:12:13 +08:00
overtrue 95c7e4218e build(rustfs): add rustfs-gateway-stream behind gateway-stack
The gateway stack's request-body bridge (batch D: PutObject, UploadPart,
PostObject) reads the gateway's streamed body type, so the rustfs crate
needs rustfs-gateway-stream as a dependency. Added as an optional
dependency enabled only by the gateway-stack feature, without the
tokio-io feature: the bridge does not need it. The workspace entry
already existed (rustfs-protocols depends on it), so the lock gains one
edge and no package.

Not built: the bridge itself; batch D writes it with its first caller.
No tests: a dependency edge has no behaviour of its own.
Verified: check_connect_release_boundary.py --features-only and
--self-test, ci_gate.py --self-test and --check-workflow.
Not compiled locally: the host is short of disk; the crate already
builds in the workspace through rustfs-protocols.
2026-11-13 12:04:29 +08:00
overtrue c43e415b09 feat(server): serve ListBuckets and HeadBucket on the gateway stack (#9296)
The walking skeleton of the gateway edge, behind the gateway-stack cargo
feature and RUSTFS_S3_STACK=gateway. rustfs-gateway inside the RustFS binary
serves ListBuckets and HeadBucket end to end and answers every other S3
operation 501 NotImplemented. A default build carries neither the stack
selection nor the wrapper: its request path is unchanged.

- One per-operation unit: impl Served for dto::Op with a metric label, an
  authorize without a default body, and an execute. The only impl Handler is
  the blanket one over Served (access phase, authorize, count, execute, one
  error mapping). authorize calls the function the legacy access hook calls.
- One table laid out per family (ten family files named after the migration
  batches); it registers the handlers and is the whole early gate.
- A shared access phase used by both edges, fed on the gateway edge from the
  gateway's verdict.
- Stored bucket names are materialised under the gateway floor only, so names
  the AWS grammar refuses are listed as before; HeadBucket's legacy edge builds
  its input the same way until the gateway re-pin (rustfs/gateway#1610).
- With the gateway selected the legacy service receives exactly what the
  legacy router claims (extension routes, object lambda, control plane).
- A start-up line names the stack the mounted service answers with.
- The release-boundary guard reads feature closures from cargo metadata.

Squashed from gw/T2.5-gateway-stack at aca434fdf onto ce9d0b153, with two
changes made while landing: the new CI job reads the ci-dev cache under its
current digest key, and the cache-reader count in scripts/test_ci_plan.py is
7 (this job is the seventh reader).

Checked: cargo clippy --locked -p rustfs --all-targets -- -D warnings in both
builds on aca434fdf (main up to eca95f297); on the squashed tree the Quick
Checks guards, the spell check, ci_gate.py --self-test and --check-workflow,
and the release-boundary tests. Not run on the squashed tree: a compile of
the rustfs crate (six small commits landed on main since the clippy run) and
any test. The legacy HeadBucket name table carries four provisional statuses
for names no store holds; they are corrected by a follow-up when the probe
of main reports.
2026-11-13 11:31:50 +08:00
cxymds ce9d0b153e fix(heal): retain legacy MRF responsibility after physical repair (#9391) 2026-11-13 11:03:53 +08:00
overtrue ef79dcbe19 ci: conformance and client-matrix lanes against both S3 stacks
Acceptance lanes T3.4 (rustfs/backlog#2775) and T3.5 (rustfs/backlog#2776):
.github/workflows/gateway-acceptance.yml runs the rustfs/gateway conformance
corpus (--profile rustfs) and client matrix (ci/compat/run_matrix.sh
--external) against the candidate binary on RUSTFS_S3_STACK=legacy and
=gateway, one server per stack. The suites are checked out at the gateway rev
Cargo.toml pins. Nightly schedule and workflow_dispatch only.

- Each stack must be observed: the start step writes `ready` only when
  /health/ready answers while its own process is alive and the server's
  server_starting event names the requested stack (scripts/dual_stack.py
  stack); otherwise `did not start: ...`. Summaries print the observed stack.
- Verdicts come from files the run leaves on disk (startup record, stack
  evidence, liveness after the corpus, exit codes, report.json, matrix.json),
  never from an earlier step's exit status.
- Conformance: the rustfs profile describes the gateway edge, so only the
  gateway stack is judged (scripts/check_conformance_rulings.py against
  .config/conformance-rulings.toml). Red: an unruled failure, a ruled case
  failing differently from its ruling's `failure`, a stale ruling, and a skip
  on the server's own answer (endpoint not answering, refused fixture). The
  legacy run is an unjudged reference: it must serve, stay up and complete.
- Client matrix (scripts/compat_matrix_report.py): per stack, red on a `fail`
  or `sut-unregistered` cell, a client that could not be installed, or an
  unfinished matrix; legacy is the baseline and every legacy pass must pass on
  gateway.
- The gateway leg and the stack comparison are continue-on-error, report-only
  until T2.10.

Not built: no re-pin (write cases need a gateway rev with
--allow-external-writes plus that flag on the lane's run line); no legacy
rulings; no use of the runner's own --rulings ledger (stale rulings do not
block there); no call to the gateway's check_compat_matrix.sh (it does not
fail `fail` cells or clients that never ran); no JUnit (the pinned runner
writes a raw U+0001); no install cache; toolchain versions copied from the
gateway's client-matrix.yml at 7915d069.

Tests: --self-test of both checkers in make script-tests, 40 tests, 31
negative. Mutations, each red: unruled failure ignored
(test_an_unruled_failure_is_red); stale only when passed
(test_a_ruling_on_a_skipped_or_absent_case_is_stale); did-not-start green
(test_a_server_that_did_not_start_is_red_and_says_why); swallowed runner exit
(test_a_swallowed_exit_cannot_hide_a_failed_case); exit 3 accepted
(test_an_environment_exit_is_red); legacy judged or tallied
(test_the_legacy_reference_is_counted_never_judged); dead server green
(test_a_server_that_died_during_the_corpus_is_red); endpoint and fixture
skips not red (test_a_skip_on_the_endpoint_not_answering_is_red,
test_a_skip_on_a_refused_fixture_is_red); ruling on id only
(test_a_ruled_case_failing_differently_is_red); unknown verdict
(test_an_unknown_verdict_is_refused); stack not compared
(test_a_server_of_the_other_stack_is_red); no stack evidence
(test_ready_without_stack_evidence_is_red); failed cell, skipped client,
swallowed matrix exit (test_a_failed_cell_is_red,
test_a_client_that_could_not_be_installed_is_skipped_never_passed,
test_a_missing_manifest_is_red_even_when_the_exit_was_swallowed); superset
gate (test_a_legacy_pass_lost_or_absent_on_gateway_is_red,
test_a_gateway_superset_of_the_baseline_is_clean_and_its_extra_passes_are_listed,
test_diff_without_both_manifests_is_red); diffs
(test_diff_lists_changed_and_absent_cases_only,
test_diff_without_both_reports_compares_nothing).

Trial runs on rustfs/rustfs#9368: 43264289490, 43325101234. Gateway stack did
not start (gateway stack is not assembled yet, T2.5); legacy reference
completed, 140 of 890 cases executable against an external endpoint; legacy
matrix 13 x 14: pass 121, fail 0, client-unsupported 61, sut-unregistered 0.

Not verified: the stack observation and liveness record in CI (exercised
locally under bash -eo pipefail with a stand-in server and main's
dual_stack.py, both directions); a scheduled run; a diff with gateway content.
2026-11-13 10:31:46 +08:00
overtrue dea9ac7fe2 refactor(admin): read target subscriptions from the stored configuration
ListTargetSubscriptions rendered each bucket's stored notification
configuration as the s3s DTO (an XML round trip) and walked it as JSON.
It now reads the routes of the stored PersistedNotificationConfiguration
directly through its behavior() projection: same order (queue, topic,
lambda), same exact destination match, same filter-rule reading
("Prefix" before "prefix", a rule without a value supplies none). The
conversion step and its two internal-error exits are gone; the function no
longer fails. admin/handlers/event.rs no longer references s3s.

Tests: the existing subscription test now starts from stored XML, the way
the handler loads it; a new test pins rule-name precedence, valueless and
nameless rules, and exact (case- and whitespace-sensitive) destination
matching. Both were run against the old code first and passed unchanged,
then against the new code. Mutation: not run yet (the build was interrupted); it follows separately.

Not verified: the workspace suite (only the touched modules' tests ran).
2026-11-13 10:27:53 +08:00
overtrue ca5ac98c6c refactor(rustfs): use owned error and header names in three files
Part of the s3s removal tail (rustfs/backlog TAIL, feeding T4.2):

- storage/options.rs: the empty Object Lock value check compares against
  the lowercase rustfs_utils names the file already imports instead of the
  s3s header constants; the comparison stays case-insensitive.
- admin/handlers/pools.rs tests: compare ApiError codes through the owned
  code (the idiom the file already uses) and read headers and status from
  the owned S3Error conversion, from which the s3s one is derived.
- init.rs: the error logged when a bucket's notification rules cannot be
  registered is built with rustfs_s3_types::s3_error!; code and message are
  unchanged, the Debug spelling in that log line is the owned type's.

Not changed: init.rs still builds s3s notification DTOs, because the notify
rule conversion it calls takes them.

Tests: empty_object_lock_values_are_not_user_metadata (4 skipped keys, 1
kept), run against the old code first and passed. Mutation: not run yet (the build was interrupted); it follows separately.

Not verified: the workspace suite (only the touched modules' tests ran).
2026-11-13 10:27:53 +08:00
overtrue 34be0a802f fix(ci): satisfy the unsafe-allowance and spelling checks on main
Two quick checks failed on main after eca95f297:

- scripts/check_unsafe_code_allowances.sh requires a SAFETY: comment next
  to an unsafe_code allowance. The comment above the allowance in
  crates/ecstore/src/erasure/codec/shard_buf.rs already stated the
  contract; it now carries the marker the guard looks for.
- The spell checker reads the byte literal b"hel" in a put.rs test as a
  misspelling. The two frames are now b"he" and b"llo"; the test still
  joins them into "hello".

No behaviour change. Checked locally: the unsafe-allowance guard, typos
over the whole tree, cargo fmt --check. Not run: clippy or tests (a
comment and a test literal).
2026-11-13 10:27:10 +08:00
Hauser Zhi 7e93d41c5d test(ecstore): reserve capacity for namespace ownership probes (#9382) 2026-11-12 21:14:42 -05:00
446 changed files with 62246 additions and 8210 deletions
+11
View File
@@ -31,3 +31,14 @@
# the flag, so the two can no longer drift apart unnoticed.
#
# For CPU profiling, add `-C force-frame-pointers=yes` to that RUSTFLAGS value.
# Exact internode HTTP/2 PING ACK timeout accounting is also deliberately
# default-off. Hyper exposes the exact timeout only through its unstable tracing
# event, so diagnostic builds must opt in to both the feature and cfg:
#
# RUSTFLAGS="--cfg hyper_unstable_tracing" \
# cargo build -p rustfs --features diagnostic-internode-http2-ping
#
# `crates/protos/build.rs` and `crates/obs/build.rs` fail fast if the feature and
# cfg drift apart. Do not move this cfg into global rustflags: doing so would
# recompile every dependency under an unstable, non-semver build contract.
+10
View File
@@ -0,0 +1,10 @@
# Rulings for the gateway conformance lane (.github/workflows/gateway-acceptance.yml).
#
# One row per case that fails on the GATEWAY stack for a reviewed reason: `case`; `ledger`, the
# rustfs/backlog#2684 entry that accepts the difference (R-0xx or K-n); a one-line `reason`; and
# `failure`, a prefix of the failure the ruling accepts, as the runner's report.json renders it
# (`[expect/status] at /expect/status: exchange #1, attempt 1: expected status 400, observed 403`).
# scripts/check_conformance_rulings.py fails the lane on a failed case without a row, on a ruled
# case whose failures do not start with its `failure`, and on a row whose case no longer fails or
# no longer exists. The legacy stack is a reference run and takes no rulings: the `rustfs` profile
# describes the gateway edge, not the legacy one.
+4
View File
@@ -39,6 +39,8 @@ script-tests: ## Run shell script tests
./scripts/test_entrypoint_directories.sh
./scripts/test_internode_grpc_ab_bench.sh
$(RUSTFS_PYTHON_BIN) ./scripts/test_internode_grpc_window.py
$(RUSTFS_PYTHON_BIN) ./scripts/test_internode_msgpack_peer_canary.py
./scripts/test_internode_msgpack_peer_canary_runner.sh
./scripts/test_object_batch_bench_enhanced.sh
./scripts/test_package_service_scripts.sh
./scripts/test_hotpath_warp_ab_gate.sh
@@ -101,6 +103,8 @@ script-tests: ## Run shell script tests
$(RUSTFS_PYTHON_BIN) ./scripts/test_junit_diff.py
$(RUSTFS_PYTHON_BIN) ./scripts/test_dual_stack.py
$(RUSTFS_PYTHON_BIN) ./scripts/test_mint_stack_diff.py
$(RUSTFS_PYTHON_BIN) ./scripts/check_conformance_rulings.py --self-test
$(RUSTFS_PYTHON_BIN) ./scripts/compat_matrix_report.py --self-test
$(RUSTFS_PYTHON_BIN) ./scripts/s3-tests/test_report_compat.py
$(RUSTFS_PYTHON_BIN) ./scripts/s3-tests/test_runner_tools.py
$(RUSTFS_PYTHON_BIN) ./scripts/s3-tests/test_api_coverage.py
+10
View File
@@ -99,6 +99,11 @@ threads-required = "num-test-threads"
filter = '(package(rustfs-ecstore) & (test(/^core::pools_test::decommission_lock_order_tests::(active_decommission_migration_does_not_invert_capacity_and_delete_object(_tag)?_locks|decommission_moves_a_transitioned_version_expired_by_a_delete_all_rule_without_stalling)$/) | test(=services::integrity::tests::audit_migration_and_ack_recovery_preserve_source_and_reject_conflicts))) | (package(rustfs-heal) & test(=heal::mrf_queue::partial_write::tests::durable_retry_submission_error_keeps_checkpoint_and_uses_backoff))'
threads-required = "num-test-threads"
# These eight-disk namespace-owner probes overlap durable cleanup with a lock contender. Reserve capacity so sibling disk fixtures cannot consume their lock and completion budgets.
[[profile.default.overrides]]
filter = 'package(rustfs-ecstore) & test(/^store::object::tests::(canceled_create_retains_usage_cleanup_namespace_owner|batch_delete_excludes_recovery_on_nonzero_pool|delete_excludes_recovery_with_(disjoint|identical|overlapping)_pool_lock_clients)$/)'
threads-required = "num-test-threads"
# These eight-disk decommission fixtures exercise concurrent retries,
# free-version cleanup, and real capacity probes under production lock deadlines.
# Reserve the run's capacity so unrelated IO cannot exhaust those budgets.
@@ -405,6 +410,11 @@ threads-required = "num-test-threads"
filter = '(package(rustfs-ecstore) & (test(/^core::pools_test::decommission_lock_order_tests::(active_decommission_migration_does_not_invert_capacity_and_delete_object(_tag)?_locks|decommission_moves_a_transitioned_version_expired_by_a_delete_all_rule_without_stalling)$/) | test(=services::integrity::tests::audit_migration_and_ack_recovery_preserve_source_and_reject_conflicts))) | (package(rustfs-heal) & test(=heal::mrf_queue::partial_write::tests::durable_retry_submission_error_keeps_checkpoint_and_uses_backoff))'
threads-required = "num-test-threads"
# These eight-disk namespace-owner probes overlap durable cleanup with a lock contender. Reserve capacity so sibling disk fixtures cannot consume their lock and completion budgets.
[[profile.ci.overrides]]
filter = 'package(rustfs-ecstore) & test(/^store::object::tests::(canceled_create_retains_usage_cleanup_namespace_owner|batch_delete_excludes_recovery_on_nonzero_pool|delete_excludes_recovery_with_(disjoint|identical|overlapping)_pool_lock_clients)$/)'
threads-required = "num-test-threads"
# These eight-disk decommission fixtures exercise concurrent retries,
# free-version cleanup, and real capacity probes under production lock deadlines.
# Reserve the run's capacity so unrelated IO cannot exhaust those budgets.
@@ -34,6 +34,9 @@ services:
- RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_UNSAFE_BYPASS_DISK_CHECK=${RUSTFS_UNSAFE_BYPASS_DISK_CHECK:-true}
- RUSTFS_DURABILITY_MODE=${RUSTFS_DURABILITY_MODE:-strict}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE:-false}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS:-0}
# Internode gRPC optimization knobs (grpc-optimization P0-P3). Defaults match the binary
# defaults, so leaving these unset is a no-op; the A/B driver exports them to toggle a stage.
- RUSTFS_INTERNODE_RPC_TCP_NODELAY=${RUSTFS_INTERNODE_RPC_TCP_NODELAY:-true}
@@ -81,6 +84,9 @@ services:
- RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_UNSAFE_BYPASS_DISK_CHECK=${RUSTFS_UNSAFE_BYPASS_DISK_CHECK:-true}
- RUSTFS_DURABILITY_MODE=${RUSTFS_DURABILITY_MODE:-strict}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE:-false}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS:-0}
# Internode gRPC optimization knobs (grpc-optimization P0-P3). Defaults match the binary
# defaults, so leaving these unset is a no-op; the A/B driver exports them to toggle a stage.
- RUSTFS_INTERNODE_RPC_TCP_NODELAY=${RUSTFS_INTERNODE_RPC_TCP_NODELAY:-true}
@@ -128,6 +134,9 @@ services:
- RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_UNSAFE_BYPASS_DISK_CHECK=${RUSTFS_UNSAFE_BYPASS_DISK_CHECK:-true}
- RUSTFS_DURABILITY_MODE=${RUSTFS_DURABILITY_MODE:-strict}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE:-false}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS:-0}
# Internode gRPC optimization knobs (grpc-optimization P0-P3). Defaults match the binary
# defaults, so leaving these unset is a no-op; the A/B driver exports them to toggle a stage.
- RUSTFS_INTERNODE_RPC_TCP_NODELAY=${RUSTFS_INTERNODE_RPC_TCP_NODELAY:-true}
@@ -175,6 +184,9 @@ services:
- RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_OBJECT_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_LOCK_ACQUIRE_TIMEOUT=${RUSTFS_LOCK_ACQUIRE_TIMEOUT:-5}
- RUSTFS_UNSAFE_BYPASS_DISK_CHECK=${RUSTFS_UNSAFE_BYPASS_DISK_CHECK:-true}
- RUSTFS_DURABILITY_MODE=${RUSTFS_DURABILITY_MODE:-strict}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_ENABLE:-false}
- RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS=${RUSTFS_EXPERIMENTAL_FILE_FDATASYNC_GROUP_COMMIT_WAIT_MICROS:-0}
# Internode gRPC optimization knobs (grpc-optimization P0-P3). Defaults match the binary
# defaults, so leaving these unset is a no-op; the A/B driver exports them to toggle a stage.
- RUSTFS_INTERNODE_RPC_TCP_NODELAY=${RUSTFS_INTERNODE_RPC_TCP_NODELAY:-true}
+53
View File
@@ -296,6 +296,34 @@
"origin": "baseline",
"alert_contract": "scheduled-validation"
},
{
"workflow": ".github/workflows/rdma-feature-check.yml",
"name": "S3-over-RDMA feature check",
"roles": [
"pr",
"periodic",
"manual"
],
"events": [
"pull_request",
"schedule",
"workflow_dispatch"
],
"cadence": "weekly",
"timezone": "UTC",
"schedule": [
"37 5 * * 1"
],
"owner": "@overtrue",
"policy": "active",
"monitor": "workflow",
"max_age_hours": 192,
"result_owner": "rdma-feature-check.yml",
"disposition": "compiles the nixl feature and runs rustfs-nixl unit tests on Linux; the feature is off in every other build",
"failure_owner": "workflow",
"origin": "added",
"alert_contract": "scheduled-validation"
},
{
"workflow": ".github/workflows/rustfs-validation-sweep.yml",
"name": "RustFS Validation Sweep",
@@ -977,6 +1005,31 @@
"origin": "baseline",
"alert_contract": "scheduled-validation"
},
{
"workflow": ".github/workflows/gateway-acceptance.yml",
"name": "Gateway Acceptance",
"roles": [
"periodic",
"manual"
],
"events": [
"schedule",
"workflow_dispatch"
],
"cadence": "nightly",
"timezone": "UTC",
"schedule": [
"29 3 * * *"
],
"owner": "@overtrue",
"policy": "active",
"monitor": "workflow",
"max_age_hours": 36,
"result_owner": "gateway-acceptance.yml",
"disposition": "gateway conformance corpus (rustfs profile) and client matrix against the candidate on both S3 stacks",
"failure_owner": "watchdog",
"origin": "added"
},
{
"workflow": ".github/workflows/gateway-integration-sync.yml",
"name": "Gateway Integration Sync",
+1 -1
View File
@@ -702,7 +702,7 @@ jobs:
uses: ./.github/actions/setup
with:
rust-version: stable
cache-shared-key: ci-dev
cache-shared-key: ci-dev-ea7eec74fe14
cache-save-if: 'false'
install-build-packaging-tools: 'false'
+50 -2
View File
@@ -25,8 +25,8 @@
# Left out of both stacks: `dual_stack_differential::` (servers with an explicit
# stack), `fake_s3_target::`, the upgrade write-readiness cases and one deadline
# case (no server), and `distributed_startup_regression_test::` (needs ci.yml's
# hooks-binary manifest). e2e-full runs without the mc, Vault and iptables
# tools ci.yml installs: their cases fail on both stacks.
# hooks-binary manifest). Both e2e-full stacks use ci.yml's pinned mc and
# Vault binaries and network fault-injection tools.
name: dual-stack-nightly
@@ -160,6 +160,54 @@ jobs:
echo "AWSCURL_PATH=$HOME/.local/bin/awscurl" >> "$GITHUB_ENV"
test -x "$HOME/.local/bin/awscurl"
- name: Install network fault-injection tools
if: matrix.profile == 'e2e-full'
run: |
sudo apt-get install -y iptables
sudo -n iptables --version
# The endpoint-blackhole heal scenario needs CAP_NET_ADMIN. Containerised
# runners can run iptables but not touch the rule set; the test then logs
# a skip instead of failing, so surface that here where it is visible.
if ! sudo -n iptables -w 5 -S OUTPUT >/dev/null 2>&1; then
echo "::warning::iptables cannot read the OUTPUT chain on this runner (no CAP_NET_ADMIN); the endpoint-blackhole heal scenario will be skipped"
fi
- name: Install mc
if: matrix.profile == 'e2e-full'
env:
GH_TOKEN: ${{ github.token }}
MC_VERSION: RELEASE.2025-08-13T08-35-41Z
MC_SHA256: 01f866e9c5f9b87c2b09116fa5d7c06695b106242d829a8bb32990c00312e891
run: |
if ! command -v gh >/dev/null 2>&1; then
sudo apt-get update
sudo apt-get install -y gh
fi
MC_BINARY="mc.linux-amd64.${MC_VERSION}"
python3 .github/actions/setup/download_release_asset.py --repository minio/mc --tag "$MC_VERSION" --asset "$MC_BINARY" --output "$RUNNER_TEMP/mc" --sha256 "$MC_SHA256"
echo "${MC_SHA256} $RUNNER_TEMP/mc" | sha256sum --check --status
chmod +x "$RUNNER_TEMP/mc"
echo "$RUNNER_TEMP" >> "$GITHUB_PATH"
- name: Verify mc
if: matrix.profile == 'e2e-full'
run: mc --version
- name: Install Vault
if: matrix.profile == 'e2e-full'
run: |
VAULT_VERSION="1.17.6"
VAULT_ARCHIVE="vault_${VAULT_VERSION}_linux_amd64.zip"
curl -fsSLo "$RUNNER_TEMP/$VAULT_ARCHIVE" "https://releases.hashicorp.com/vault/${VAULT_VERSION}/${VAULT_ARCHIVE}"
echo "0cddc1fbbb88583b5ba5b845f9f8fae47c6fb39a6d48cd543c6ba6fd3ac1a669 $RUNNER_TEMP/$VAULT_ARCHIVE" | sha256sum --check --status
unzip -q "$RUNNER_TEMP/$VAULT_ARCHIVE" -d "$RUNNER_TEMP/vault-bin"
echo "RUSTFS_TEST_VAULT_BIN=$RUNNER_TEMP/vault-bin/vault" >> "$GITHUB_ENV"
- name: Verify Vault
if: matrix.profile == 'e2e-full'
run: |
"$RUSTFS_TEST_VAULT_BIN" version
- name: Run the profile on the ${{ matrix.stack }} stack
env:
PROFILE: ${{ matrix.profile }}
@@ -65,6 +65,7 @@ jobs:
strategy: { fail-fast: false, matrix: { stack: [legacy, gateway] } }
env:
FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
RUSTFS_BUILD_FEATURES: ${{ matrix.stack == 'gateway' && 'gateway-stack' || '' }}
steps:
- name: Checkout repository
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
@@ -96,7 +97,7 @@ jobs:
# Build once and carry its source/binary identity into the test invocation.
- name: Build rustfs binary
run: |
python3 scripts/e2e_binary.py build --bins
python3 scripts/e2e_binary.py build --bins --features "$RUSTFS_BUILD_FEATURES"
# A gateway binary that refuses to start skips the suite; the summary says why.
- name: Gateway preflight
@@ -114,7 +115,7 @@ jobs:
env:
RUSTFS_E2E_LOG_DIR: ${{ runner.temp }}/rustfs-e2e-repl-nightly-logs
RUSTFS_S3_STACK: ${{ matrix.stack }}
run: python3 scripts/e2e_binary.py run -- cargo nextest run --profile e2e-repl-nightly -p e2e_test
run: python3 scripts/e2e_binary.py run --features "$RUSTFS_BUILD_FEATURES" -- cargo nextest run --profile e2e-repl-nightly -p e2e_test
- name: Prove the stack and upload the leg
if: always()
@@ -213,7 +214,7 @@ jobs:
strategy: { fail-fast: false, matrix: { stack: [legacy, gateway] } }
env:
FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
RUSTFS_BUILD_FEATURES: ftps,webdav,sftp
RUSTFS_BUILD_FEATURES: ${{ matrix.stack == 'gateway' && 'ftps,webdav,sftp,gateway-stack' || 'ftps,webdav,sftp' }}
steps:
- name: Checkout repository
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
+395
View File
@@ -0,0 +1,395 @@
# Copyright 2026 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.
# Gateway black-box acceptance lanes (rustfs/backlog#2775 T3.4, #2776 T3.5).
#
# Runs two suites of the rustfs/gateway repository against the candidate binary,
# once per S3 stack (RUSTFS_S3_STACK=legacy and =gateway), one server per stack:
#
# - the conformance corpus, `--profile rustfs`. That profile describes the
# gateway edge, so scripts/check_conformance_rulings.py judges the gateway
# stack against .config/conformance-rulings.toml (red: an unruled failure, a
# ruled case failing differently, a stale ruling, a skip on the server's own
# answer) and publishes the legacy run as a reference that is never judged:
# it only has to serve, stay up and complete;
# - the client matrix, ci/compat/run_matrix.sh --external, judged per stack by
# scripts/compat_matrix_report.py (no `fail`, no `sut-unregistered`, every
# client ran; a client that could not be installed is reported as skipped).
# The legacy matrix is the baseline: every cell that passes on legacy must
# pass on gateway (`compare`).
#
# The suites are checked out at the rustfs/gateway rev Cargo.toml pins, so the
# suite and the framework under test never drift apart. The verdict of each
# stack is computed from what the run left on disk (startup record, the stack
# the server's own log names, runner exit code, liveness after the corpus,
# report), never from the exit status of an earlier step. Needs
# scripts/dual_stack.py and the `s3_stack` startup field of rustfs/rustfs#9367.
#
# The gateway stack is report-only until T2.10: its job may fail without failing
# the workflow, and its summary says what it observed (did not start, or how many
# cases ran, passed, failed and were answered 501). The stack comparison is
# report-only for the same reason; its conformance half is information only.
#
# Not a pull-request gate. Scheduled failures are owned by the scheduled-validation
# watchdog (.github/scheduled-validations.json).
name: Gateway Acceptance
on:
schedule:
- cron: "29 3 * * *"
workflow_dispatch:
# Matches ci.yml: these variables are hashed into the rust-cache key, so the
# candidate build reads the same ci-dev cache as build-rustfs-debug-binary.
env:
CARGO_TERM_COLOR: always
RUST_BACKTRACE: 1
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
permissions:
contents: read
defaults:
run:
shell: bash
jobs:
plan:
name: Read the gateway pin
runs-on: ubuntu-latest
timeout-minutes: 5
outputs:
gateway-rev: ${{ steps.pin.outputs.rev }}
steps:
- name: Checkout repository
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
with:
persist-credentials: false
- name: Read the rustfs/gateway rev from Cargo.toml
id: pin
run: |
set -euo pipefail
python3 - <<'PY' >> "$GITHUB_OUTPUT"
import re, sys, tomllib
dependencies = tomllib.load(open("Cargo.toml", "rb"))["workspace"]["dependencies"]
revs = {spec.get("rev") for spec in dependencies.values()
if isinstance(spec, dict) and spec.get("git") == "https://github.com/rustfs/gateway.git"}
if len(revs) != 1 or not re.fullmatch(r"[0-9a-f]{40}", str(next(iter(revs)))):
sys.exit(f"Cargo.toml must pin rustfs/gateway at exactly one full rev, found {sorted(map(str, revs))}")
print(f"rev={revs.pop()}")
PY
cat "$GITHUB_OUTPUT"
build-candidate:
name: Build candidate binary
# The same debug build as ci.yml's build-rustfs-debug-binary, reading the
# ci-dev cache written on sm-standard-4.
runs-on: sm-standard-4
timeout-minutes: 60
env:
FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
steps:
- name: Checkout repository
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
with:
persist-credentials: false
- name: Setup Rust environment
uses: ./.github/actions/setup
with:
rust-version: stable
cache-shared-key: ci-dev
cache-save-if: 'false'
install-build-packaging-tools: 'false'
- name: Build debug binary
run: python3 scripts/e2e_binary.py build --bins --features e2e-test-hooks
- name: Upload candidate binary
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
with:
name: gateway-acceptance-candidate-binary
overwrite: true
path: |
target/debug/rustfs
target/debug/rustfs.e2e.json
if-no-files-found: error
retention-days: 1
build-gateway-tools:
name: Build gateway conformance runner and compat-sut
needs: [ plan ]
# The gateway workspace builds with its own rust-toolchain.toml, which rustup
# installs on first use; nothing here names a toolchain.
runs-on: ubuntu-latest
timeout-minutes: 60
steps:
- name: Checkout rustfs/gateway at the pinned rev
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
with:
repository: rustfs/gateway
ref: ${{ needs.plan.outputs.gateway-rev }}
path: gateway
persist-credentials: false
- name: Build
working-directory: gateway
run: |
cargo build --locked --release -p rustfs-gateway-conformance -p rustfs-gateway-compat-sut \
--bin rustfs-gateway-conformance --bin compat-sut
- name: Upload tools
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
with:
name: gateway-acceptance-tools
overwrite: true
path: |
gateway/target/release/rustfs-gateway-conformance
gateway/target/release/compat-sut
if-no-files-found: error
retention-days: 1
acceptance:
name: ${{ matrix.stack == 'gateway' && 'Acceptance (gateway, report-only until T2.10)' || 'Acceptance (legacy)' }}
needs: [ plan, build-candidate, build-gateway-tools ]
# GitHub-hosted like the s3-tests targets of reference-parity.yml: the job
# only runs prebuilt binaries and the pinned clients, none of which needs Docker.
runs-on: ubuntu-latest
# About 3x the 15 minutes the legacy job took in run 43325101234 (client install about
# 8, matrix about 3, corpus about 3), so a hung server costs 45 runner minutes, not more.
timeout-minutes: 45
continue-on-error: ${{ matrix.stack == 'gateway' }}
strategy:
fail-fast: false
matrix:
stack: [ legacy, gateway ]
env:
STACK: ${{ matrix.stack }}
ENDPOINT: http://127.0.0.1:9000
# The conformance suite signs with these fixed fixture credentials (the AWS
# documentation example pair), so the candidate is started with them and the
# client matrix is handed the same pair.
ACCESS_KEY: AKIAIOSFODNN7EXAMPLE
SECRET_KEY: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
steps:
- name: Checkout repository
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
with:
persist-credentials: false
- name: Checkout rustfs/gateway at the pinned rev
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
with:
repository: rustfs/gateway
ref: ${{ needs.plan.outputs.gateway-rev }}
path: gateway
persist-credentials: false
- name: Download candidate binary
uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
with:
name: gateway-acceptance-candidate-binary
path: target/debug
- name: Download gateway tools
uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
with:
name: gateway-acceptance-tools
path: tools
# Records `ready`, or what the process said when it exited, in lane/startup.txt. `ready`
# also needs the server's own `server_starting` log event to name the requested stack
# (its `s3_stack` field comes from rustfs/rustfs#9367; scripts/dual_stack.py reads it).
- name: Start candidate (${{ matrix.stack }} stack)
run: |
set -uo pipefail
chmod +x target/debug/rustfs tools/*
mkdir -p lane "$RUNNER_TEMP"/data/rustfs{0..3}
target/debug/rustfs --version | tee lane/candidate-version.txt
# The four directories share the runner's one disk; the bypass is the CI case the
# physical-disk guard sanctions (as in mint.yml).
RUSTFS_S3_STACK="$STACK" RUSTFS_UNSAFE_BYPASS_DISK_CHECK=true RUST_LOG=info target/debug/rustfs --address 127.0.0.1:9000 \
--access-key "$ACCESS_KEY" --secret-key "$SECRET_KEY" "$RUNNER_TEMP"/data/rustfs{0..3} \
> lane/rustfs.log 2>&1 &
pid=$!
echo "$pid" > lane/rustfs.pid
# Liveness first: a ready answer counts only while this process is still running.
for _ in $(seq 120); do
if ! kill -0 "$pid" 2>/dev/null; then
status=0
wait "$pid" || status=$?
echo "did not start: exit ${status}: $(grep -v '^[[:space:]]*$' lane/rustfs.log | tail -n 1)" > lane/startup.txt
cat lane/startup.txt
exit 1
fi
if curl -sf "$ENDPOINT/health/ready" >/dev/null; then
if python3 scripts/dual_stack.py stack --expect "$STACK" --out lane/stack.json lane/rustfs.log > /dev/null; then
echo ready > lane/startup.txt
exit 0
fi
echo "did not start: stack not observed" > lane/startup.txt
cat lane/startup.txt
exit 1
fi
sleep 1
done
echo "did not start: /health/ready did not answer within 120 seconds" > lane/startup.txt
exit 1
# The exit code is data for the judge step, not this step's result.
- name: Run gateway conformance (rustfs profile)
run: |
set +e
tools/rustfs-gateway-conformance run --root gateway/conformance --profile rustfs \
--endpoint "$ENDPOINT" --allow-external-fixtures \
--json lane/report.json > lane/conformance.log 2>&1
echo "$?" > lane/runner-exit.txt
if kill -0 "$(cat lane/rustfs.pid)" 2>/dev/null; then echo alive; else echo exited; fi > lane/alive-after-conformance.txt
tail -n 20 lane/conformance.log
- name: Set up Python
uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
with:
python-version: "3.12"
# Toolchains for the matrix's SDK driver programs, as the gateway's own
# client-matrix.yml sets them up; the client versions come from
# gateway/compat/versions.toml.
- uses: actions/setup-go@41dfa10bad2bb2ae585af6ee5bb4d7d973ad74ed # v5.1.0
with:
go-version: "1.26"
cache: false
- uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 # v7.0.0
with:
node-version: "22"
- uses: actions/setup-dotnet@67a3573c9a986a3f9c594539f4ab511d57bb3ce9 # v4.3.1
with:
dotnet-version: "8.0.x"
- uses: actions/setup-java@cf277c60eb25467037889841efdb72551f06f6c3 # v4.9.1
with:
distribution: temurin
java-version: "21"
- name: Install Maven
env:
MAVEN_VERSION: "3.9.16"
MAVEN_SHA512: "831a8591fe20c8243b1dbe7d71e3244f31d1665b0804b2e825e38cbbe5ce0cafb8338851f90780735568773e0a6cd07bbec107cda0b896b008b861075358b6f6"
run: |
set -euo pipefail
archive="$RUNNER_TEMP/apache-maven.tar.gz"
curl -sSfL -o "$archive" "https://archive.apache.org/dist/maven/maven-3/${MAVEN_VERSION}/binaries/apache-maven-${MAVEN_VERSION}-bin.tar.gz"
echo "${MAVEN_SHA512} ${archive}" | sha512sum -c -
tar -xzf "$archive" -C "$RUNNER_TEMP"
echo "$RUNNER_TEMP/apache-maven-${MAVEN_VERSION}/bin" >> "$GITHUB_PATH"
# One client at a time, so a client that cannot be installed is reported
# as skipped with its reason instead of stopping the others.
- name: Install pinned clients
working-directory: gateway
run: |
set -uo pipefail
python3 -m pip install --disable-pip-version-check "pyyaml==6.0.2"
installed=()
for client in $(python3 -c 'import tomllib; print(" ".join(sorted(tomllib.load(open("compat/versions.toml", "rb"))["clients"])))'); do
if bash ci/compat/install_clients.sh --clients "$client" > "../lane/install-${client}.log" 2>&1; then
installed+=("$client")
else
echo "${client}: skipped: $(tail -n 1 "../lane/install-${client}.log")" >> ../lane/skipped-clients.txt
fi
done
echo "COMPAT_CLIENTS=$(IFS=,; echo "${installed[*]}")" >> "$GITHUB_ENV"
cat ../lane/skipped-clients.txt 2>/dev/null || echo "every pinned client installed"
# The exit code is data for the judge step, not this step's result.
- name: Run client matrix (external)
working-directory: gateway
env:
GATEWAY_COMPAT_SUT_BIN: ${{ github.workspace }}/tools/compat-sut
GATEWAY_COMPAT_RUN_DIR: ${{ github.workspace }}/lane/compat
GATEWAY_COMPAT_MATRIX_OUT: ${{ github.workspace }}/lane/compat/matrix.json
run: |
set +e
export GATEWAY_COMPAT_ACCESS_KEY="$ACCESS_KEY" GATEWAY_COMPAT_SECRET_KEY="$SECRET_KEY"
PATH="$(go env GOPATH)/bin:$PATH"
if [[ -f ../lane/skipped-clients.txt ]]; then
bash ci/compat/run_matrix.sh --external "$ENDPOINT" --product rustfs --clients "$COMPAT_CLIENTS"
else
bash ci/compat/run_matrix.sh --external "$ENDPOINT" --product rustfs
fi
echo "$?" > ../lane/matrix-exit.txt
- name: Judge and summarize
if: always()
run: |
set -uo pipefail
status=0
python3 scripts/check_conformance_rulings.py --stack "$STACK" --run-dir lane | tee -a "$GITHUB_STEP_SUMMARY" || status=1
python3 scripts/compat_matrix_report.py check --stack "$STACK" --run-dir lane | tee -a "$GITHUB_STEP_SUMMARY" || status=1
exit "$status"
- name: Upload lane results
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
with:
name: gateway-acceptance-lane-${{ matrix.stack }}
overwrite: true
path: |
lane/*.txt
lane/*.log
lane/report.json
lane/stack.json
lane/compat/matrix.json
lane/compat/probe.jsonl
lane/compat/sut.log
lane/compat/results/**
if-no-files-found: error
retention-days: 14
compare:
name: Compare stacks (report-only until T2.10)
needs: [ acceptance ]
if: always()
runs-on: ubuntu-latest
timeout-minutes: 10
continue-on-error: true
steps:
- name: Checkout repository
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
with:
persist-credentials: false
- name: Download lane results
uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
with:
pattern: gateway-acceptance-lane-*
path: lanes
- name: Diff legacy and gateway
run: |
set -uo pipefail
status=0
{
python3 scripts/check_conformance_rulings.py \
--diff lanes/gateway-acceptance-lane-legacy lanes/gateway-acceptance-lane-gateway || status=1
echo
python3 scripts/compat_matrix_report.py diff \
--legacy lanes/gateway-acceptance-lane-legacy --gateway lanes/gateway-acceptance-lane-gateway || status=1
} > diff.md
cat diff.md
cat diff.md >> "$GITHUB_STEP_SUMMARY"
exit "$status"
+91
View File
@@ -0,0 +1,91 @@
name: S3-over-RDMA feature check
# The `nixl` and `cuobject` features are off in every other build, so the code
# behind them is compiled nowhere else. This job compiles the `nixl` half on
# Linux and runs rustfs-nixl's unit tests; nixl-sys builds through its stub
# fallback, so no NIXL SDK is needed.
# The cuObject half needs the NVIDIA cuObject SDK and is not compiled here.
# Not a required check and not part of the `Test and Lint` aggregate.
on:
pull_request:
paths:
- "crates/nixl/**"
- "crates/cuobject/**"
- "rustfs/src/storage/rpc/nixl*"
- "rustfs/src/app/object/cuobject.rs"
- "rustfs/src/app/object/get.rs"
- "rustfs/src/app/object/put.rs"
- "rustfs/src/app/multipart_usecase/upload_part.rs"
- "Cargo.toml"
- "rustfs/Cargo.toml"
- ".github/workflows/rdma-feature-check.yml"
schedule:
- cron: "37 5 * * 1"
workflow_dispatch:
permissions:
contents: read
concurrency:
group: rdma-feature-check-${{ github.ref }}
cancel-in-progress: true
jobs:
nixl-check:
name: cargo check and unit tests (nixl)
runs-on: sm-standard-4
timeout-minutes: 60
env:
FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
steps:
- name: Checkout repository
uses: actions/checkout@f548e57e544e1ff5a4c46bf1e1b8685f8e4a348a # v7
with:
persist-credentials: false
- name: Setup Rust environment
uses: ./.github/actions/setup
with:
rust-version: stable
cache-shared-key: ci-feat-nixl
cache-save-if: 'false'
install-build-packaging-tools: 'false'
- name: Install only missing native build tools
run: |
packages=()
command -v g++ >/dev/null || packages+=(g++)
ldconfig -p | grep -q 'libclang' || packages+=(libclang-dev)
if (( ${#packages[@]} )); then
sudo apt-get update
sudo apt-get install --no-install-recommends -y "${packages[@]}"
fi
- name: Check the nixl feature build
run: cargo check --locked -p rustfs --features nixl
# These unit tests use a fake sysfs and plain host memory; none needs an
# RDMA device or the NIXL libraries.
- name: Run the rustfs-nixl unit tests
run: cargo test --locked -p rustfs-nixl --features sys
alert-on-failure:
name: Alert on scheduled failure
needs: [nixl-check]
# Only scheduled runs open or update the tracking issue; pull-request and
# manual runs stay quiet.
if: always() && github.event_name == 'schedule' && contains(needs.*.result, 'failure')
runs-on: ubuntu-latest
timeout-minutes: 10
permissions:
contents: read
issues: write
steps:
- uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7
with:
persist-credentials: false
- name: Open or update failure-tracking issue
uses: ./.github/actions/schedule-failure-issue
with:
github-token: ${{ secrets.BACKLOG_ISSUE_TOKEN }}
+2
View File
@@ -44,6 +44,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Fixed
- **Vault KMS backends no longer fail when the server answers reads from a replica**: a Vault or OpenBao node that serves reads locally (an OpenBao standby, a Vault Enterprise performance standby) can return the state from before a write for a short while after acknowledging it. Against such a node the KV2 backend failed every key creation with `404 Key not found` while leaving the key stored without its description and tags, failed operations issued right after a create or update with `Key not found` or `Concurrent modification`, and the Transit backend failed a disable followed quickly by an enable. Key creation on the KV2 backend is now a single create-only write that carries the description and tags. Both backends now re-read a key record when the answer is older than a write the same RustFS node made in the previous five seconds, pause before re-reading after a lost check-and-set write and allow five attempts instead of three, and retry a Transit key delete that is refused because the deletion switch is not visible yet. A different RustFS node reading the same replica can still observe the earlier state until the replica catches up; see [OpenBao as the Vault KMS backend](docs/operations/kms-openbao-compatibility.md).
- **KMS keys could not be described by ARN through the path route**: `GET /rustfs/admin/v3/kms/keys/{key_id}` read the path segment verbatim, so a key id that has to be percent-encoded to fit in one segment — an AWS key ARN, with its `:` and `/` — was looked up, authorized and audited under its encoded spelling and answered `404`. The segment is now percent-decoded first; a segment that is not valid UTF-8 after decoding is refused with `400 InvalidArgument`. The `describe-key?keyId=` form was unaffected.
- **SSE-KMS objects written through the AWS KMS backend could not be read**: `GetObject`, `CopyObject` and every other read of an `aws:kms` object failed with `400 InvalidRequest` ("SSE-S3 requires RUSTFS_SSE_S3_MASTER_KEY to be set ...") on a deployment using `RUSTFS_KMS_BACKEND=aws`, although the write and `HeadObject` succeeded. The AWS backend stored the `GenerateDataKey` blob as it came from AWS, the read path took those unrecognized bytes for a locally wrapped key, and AWS was never asked to decrypt. The backend now stores the blob inside the same data-key envelope the other backends use, and a blob stored without one is routed to AWS when the AWS backend is active. Objects written by 1.0.4 and 1.0.5 are intact and become readable after the upgrade, with no rewrite. Setting `RUSTFS_SSE_S3_MASTER_KEY` was never a workaround. An object written by this release is not readable by an older one; the same was already true of every object the older release wrote itself.
Generated
+363 -83
View File
@@ -255,7 +255,7 @@ version = "1.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
dependencies = [
"windows-sys 0.61.2",
"windows-sys 0.60.2",
]
[[package]]
@@ -266,7 +266,7 @@ checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
dependencies = [
"anstyle",
"once_cell_polyfill",
"windows-sys 0.61.2",
"windows-sys 0.60.2",
]
[[package]]
@@ -1004,7 +1004,7 @@ version = "0.14.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b744eed18cd75d814effdf2aba2880f912abe0fe1c327b361341d31aba9a7005"
dependencies = [
"bindgen",
"bindgen 0.73.2",
"cc",
"cmake",
"dunce",
@@ -1618,6 +1618,26 @@ dependencies = [
"serde",
]
[[package]]
name = "bindgen"
version = "0.71.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3"
dependencies = [
"bitflags 2.13.2",
"cexpr",
"clang-sys",
"itertools 0.13.0",
"log",
"prettyplease 0.2.37",
"proc-macro2",
"quote",
"regex",
"rustc-hash",
"shlex 1.3.0",
"syn 2.0.119",
]
[[package]]
name = "bindgen"
version = "0.73.2"
@@ -1633,7 +1653,7 @@ dependencies = [
"quote",
"regex",
"rustc-hash",
"shlex",
"shlex 2.0.1",
"syn 3.0.10",
]
@@ -1766,6 +1786,15 @@ dependencies = [
"hybrid-array",
]
[[package]]
name = "block2"
version = "0.6.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cdeb9d870516001442e364c5220d3574d2da8dc765554b4a617230d33fa58ef5"
dependencies = [
"objc2",
]
[[package]]
name = "blocking"
version = "1.7.0"
@@ -1898,9 +1927,9 @@ dependencies = [
[[package]]
name = "bumpalo"
version = "3.20.3"
version = "3.20.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
checksum = "87a0cf66fd1eb2fb7b822cb78370d82303750809bc6ba855f3f58e517d3238db"
[[package]]
name = "bytemuck"
@@ -1986,7 +2015,7 @@ dependencies = [
"maybe-owned",
"rustix",
"rustix-linux-procfs",
"windows-sys 0.61.2",
"windows-sys 0.60.2",
"winx",
]
@@ -2080,14 +2109,14 @@ dependencies = [
[[package]]
name = "cc"
version = "1.11.1"
version = "1.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ff2a8126fff0f8c839080d619675a585e61720bb12d2baceae45769fd66f155"
checksum = "33ef9e3e8154a45c7a95cff4c1299702106ad94062d7bb85fdc5d3a5afd91d45"
dependencies = [
"find-msvc-tools",
"jobserver",
"libc",
"shlex",
"shlex 2.0.1",
]
[[package]]
@@ -2771,6 +2800,27 @@ dependencies = [
"subtle",
]
[[package]]
name = "cuobject"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "486fec9045f8057131bf4bba71fbb87bf9dd3e44f853622cf7fa42713f3a108c"
dependencies = [
"cuobject-sys",
"memmap2",
"thiserror 2.0.21",
]
[[package]]
name = "cuobject-sys"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "edc615b2a037eb0d80180d202f809629155742db9c9e94b9f7696b1100a7d52f"
dependencies = [
"bindgen 0.73.2",
"cc",
]
[[package]]
name = "curve25519-dalek"
version = "4.1.3"
@@ -4083,7 +4133,7 @@ dependencies = [
"libc",
"option-ext",
"redox_users",
"windows-sys 0.61.2",
"windows-sys 0.59.0",
]
[[package]]
@@ -4162,7 +4212,7 @@ dependencies = [
"md-5",
"minlz",
"opentelemetry-proto",
"prost 0.14.5",
"prost 0.14.6",
"rand 0.10.3",
"rcgen",
"reqwest",
@@ -4397,7 +4447,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e35d6e78f4cebb90e51d543db8fe41528851d6deeef6ef21ebd4bfdc1e784776"
dependencies = [
"libc",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -4865,7 +4915,7 @@ dependencies = [
"hmac 0.13.0",
"http 1.5.0",
"jiff",
"jsonwebtoken",
"jsonwebtoken 11.1.0",
"reqwest",
"rustc_version",
"rustls",
@@ -4923,8 +4973,8 @@ dependencies = [
"opentelemetry_sdk",
"percent-encoding",
"pin-project",
"prost 0.14.5",
"prost-types 0.14.5",
"prost 0.14.6",
"prost-types 0.14.6",
"reqwest",
"rustc_version",
"serde",
@@ -5030,8 +5080,8 @@ dependencies = [
"jiff",
"md5",
"percent-encoding",
"prost 0.14.5",
"prost-types 0.14.5",
"prost 0.14.6",
"prost-types 0.14.6",
"serde",
"serde_json",
"serde_with",
@@ -5537,6 +5587,7 @@ dependencies = [
"pin-project-lite",
"smallvec",
"tokio",
"tracing",
"want",
]
@@ -6027,10 +6078,26 @@ dependencies = [
"base64 0.22.1",
"getrandom 0.2.17",
"js-sys",
"pem 3.0.6",
"serde",
"serde_json",
"signature 2.2.0",
"zeroize",
]
[[package]]
name = "jsonwebtoken"
version = "12.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f347a975eb5fa8f5c4eadce6c1152c11c326cf32cf839fb64ff12d5cb8f4ce8b"
dependencies = [
"aws-lc-rs",
"base64 0.23.1",
"getrandom 0.4.3",
"js-sys",
"pem 4.0.0",
"serde",
"serde_json",
"signature 3.0.0",
"simple_asn1",
"zeroize",
]
@@ -6281,9 +6348,9 @@ dependencies = [
[[package]]
name = "libunftp"
version = "0.24.0"
version = "0.25.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d94587cfb90dd87b7cced3bff07d32cb56ad1192baa5d688dfaa8728f22d48d"
checksum = "96b019a8d208e2672b68fddc84cc9f15c64df3b717b58773d3b2c9dd28729b30"
dependencies = [
"async-trait",
"bitflags 2.13.2",
@@ -6700,9 +6767,9 @@ dependencies = [
[[package]]
name = "mio"
version = "1.2.4"
version = "1.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1788edb87fdc09c7e26304471e2f5be8cdefb1b6930d6e3985fc02ff53bf86ee"
checksum = "20521a903f02b0a573cd6840e9d0a5a0cc043d361fe924092cd70f8556cc9c4a"
dependencies = [
"libc",
"wasi 0.11.1+wasi-snapshot-preview1",
@@ -6940,6 +7007,23 @@ dependencies = [
"libc",
]
[[package]]
name = "nixl-sys"
version = "1.6.0"
source = "git+https://github.com/houseme/nixl?rev=cc636c83f13d692e85b67e55aed092413d16fb41#cc636c83f13d692e85b67e55aed092413d16fb41"
dependencies = [
"anyhow",
"bindgen 0.71.1",
"cc",
"libc",
"os_info",
"pkg-config",
"serde",
"thiserror 2.0.21",
"tracing",
"wincode",
]
[[package]]
name = "nkeys"
version = "0.4.5"
@@ -6989,7 +7073,7 @@ version = "0.50.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
dependencies = [
"windows-sys 0.61.2",
"windows-sys 0.59.0",
]
[[package]]
@@ -7171,6 +7255,27 @@ dependencies = [
"objc2-encode",
]
[[package]]
name = "objc2-cloud-kit"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73ad74d880bb43877038da939b7427bba67e9dd42004a18b809ba7d87cee241c"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-foundation",
]
[[package]]
name = "objc2-core-data"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
dependencies = [
"objc2",
"objc2-foundation",
]
[[package]]
name = "objc2-core-foundation"
version = "0.3.2"
@@ -7182,6 +7287,51 @@ dependencies = [
"objc2",
]
[[package]]
name = "objc2-core-graphics"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807"
dependencies = [
"bitflags 2.13.2",
"dispatch2",
"objc2",
"objc2-core-foundation",
"objc2-io-surface",
]
[[package]]
name = "objc2-core-image"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e5d563b38d2b97209f8e861173de434bd0214cf020e3423a52624cd1d989f006"
dependencies = [
"objc2",
"objc2-foundation",
]
[[package]]
name = "objc2-core-location"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca347214e24bc973fc025fd0d36ebb179ff30536ed1f80252706db19ee452009"
dependencies = [
"objc2",
"objc2-foundation",
]
[[package]]
name = "objc2-core-text"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0cde0dfb48d25d2b4862161a4d5fcc0e3c24367869ad306b0c9ec0073bfed92d"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-core-foundation",
"objc2-core-graphics",
]
[[package]]
name = "objc2-encode"
version = "4.1.0"
@@ -7195,7 +7345,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272"
dependencies = [
"bitflags 2.13.2",
"block2",
"libc",
"objc2",
"objc2-core-foundation",
]
[[package]]
@@ -7208,6 +7361,17 @@ dependencies = [
"objc2-core-foundation",
]
[[package]]
name = "objc2-io-surface"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "180788110936d59bab6bd83b6060ffdfffb3b922ba1396b312ae795e1de9d81d"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-core-foundation",
]
[[package]]
name = "objc2-open-directory"
version = "0.3.2"
@@ -7219,6 +7383,18 @@ dependencies = [
"objc2-foundation",
]
[[package]]
name = "objc2-quartz-core"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-core-foundation",
"objc2-foundation",
]
[[package]]
name = "objc2-system-configuration"
version = "0.3.2"
@@ -7228,6 +7404,37 @@ dependencies = [
"objc2-core-foundation",
]
[[package]]
name = "objc2-ui-kit"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22"
dependencies = [
"bitflags 2.13.2",
"block2",
"objc2",
"objc2-cloud-kit",
"objc2-core-data",
"objc2-core-foundation",
"objc2-core-graphics",
"objc2-core-image",
"objc2-core-location",
"objc2-core-text",
"objc2-foundation",
"objc2-quartz-core",
"objc2-user-notifications",
]
[[package]]
name = "objc2-user-notifications"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9df9128cbbfef73cda168416ccf7f837b62737d748333bfe9ab71c245d76613e"
dependencies = [
"objc2",
"objc2-foundation",
]
[[package]]
name = "object"
version = "0.36.7"
@@ -7417,7 +7624,7 @@ dependencies = [
"opentelemetry-http",
"opentelemetry-proto",
"opentelemetry_sdk",
"prost 0.14.5",
"prost 0.14.6",
"reqwest",
"thiserror 2.0.21",
]
@@ -7430,7 +7637,7 @@ checksum = "d576f5dddc3299341bcd85a04be17b2564844c0c9563214f02d85f2524d1afae"
dependencies = [
"opentelemetry",
"opentelemetry_sdk",
"prost 0.14.5",
"prost 0.14.6",
]
[[package]]
@@ -7492,6 +7699,22 @@ dependencies = [
"num-traits",
]
[[package]]
name = "os_info"
version = "3.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9cf20a545b305cf1da722b236b5155c9bb35f1d5ceb28c048bd96ca842f41b5b"
dependencies = [
"android_system_properties",
"log",
"nix 0.31.3",
"objc2",
"objc2-foundation",
"objc2-ui-kit",
"serde",
"windows-sys 0.61.2",
]
[[package]]
name = "ouroboros"
version = "0.18.5"
@@ -7743,6 +7966,12 @@ dependencies = [
"phc",
]
[[package]]
name = "pastey"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4"
[[package]]
name = "path-absolutize"
version = "4.0.1"
@@ -8391,12 +8620,12 @@ dependencies = [
[[package]]
name = "prost"
version = "0.14.5"
version = "0.14.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c9f016da56b311cff4659f5e7335c4d5fda5ca86cae4f48b8ce1cf3335246a7d"
checksum = "3ef0b569d1d907ab3a28596aee62cf1f61dacb0529a4bedcd8e7460e2d5228b4"
dependencies = [
"bytes",
"prost-derive 0.14.5",
"prost-derive 0.14.6",
]
[[package]]
@@ -8421,9 +8650,9 @@ dependencies = [
[[package]]
name = "prost-build"
version = "0.14.5"
version = "0.14.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f461f69b0cacd7a9c2bcac932e0f3a22cb13c29fc9023092502995a771a10491"
checksum = "b6e4d69d0fa3e7f6f9cf6b53a0e83e4fc99ba3586f65ce166cff30bd13bb4ad2"
dependencies = [
"heck 0.5.0",
"itertools 0.15.0",
@@ -8431,8 +8660,8 @@ dependencies = [
"multimap",
"petgraph 0.8.3",
"prettyplease 0.3.0",
"prost 0.14.5",
"prost-types 0.14.5",
"prost 0.14.6",
"prost-types 0.14.6",
"pulldown-cmark",
"pulldown-cmark-to-cmark",
"regex",
@@ -8455,9 +8684,9 @@ dependencies = [
[[package]]
name = "prost-derive"
version = "0.14.5"
version = "0.14.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c9a367f131d93b3395fc6207c11e67098493ab040def4ce3085adbf186687f7e"
checksum = "1ad9c5423459fa2f729b8d9235fab810aa29628b171467744fc86d21460ad70d"
dependencies = [
"anyhow",
"itertools 0.15.0",
@@ -8477,11 +8706,11 @@ dependencies = [
[[package]]
name = "prost-types"
version = "0.14.5"
version = "0.14.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96e89651c132da91958fd6092a2f7262c2c36c08df4f68af0bb3591caacbbb45"
checksum = "f29a7c4c7a84cef41a53d338a2d10d4f1b043ea5c3dde26db22ee2c9c1b1c75b"
dependencies = [
"prost 0.14.5",
"prost 0.14.6",
]
[[package]]
@@ -8573,7 +8802,7 @@ dependencies = [
"nix 0.31.3",
"object 0.40.0",
"once_cell",
"prost 0.14.5",
"prost 0.14.6",
"reqwest",
"ruzstd",
"serde_json",
@@ -8797,7 +9026,7 @@ dependencies = [
"once_cell",
"socket2",
"tracing",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -9612,7 +9841,7 @@ dependencies = [
"percent-encoding",
"pin-project-lite",
"proptest",
"prost 0.14.5",
"prost 0.14.6",
"pyroscope",
"quick-xml 0.42.0",
"quinn",
@@ -9629,12 +9858,14 @@ dependencies = [
"rustfs-config",
"rustfs-credentials",
"rustfs-crypto",
"rustfs-cuobject",
"rustfs-data-usage",
"rustfs-ecstore",
"rustfs-extension-schema",
"rustfs-filemeta",
"rustfs-gateway",
"rustfs-gateway-adapter",
"rustfs-gateway-stream",
"rustfs-gateway-types",
"rustfs-heal",
"rustfs-heal-contracts",
@@ -9649,6 +9880,7 @@ dependencies = [
"rustfs-madmin",
"rustfs-mimalloc",
"rustfs-mimalloc-sys",
"rustfs-nixl",
"rustfs-notify",
"rustfs-object-capacity",
"rustfs-object-data-cache",
@@ -9743,7 +9975,6 @@ dependencies = [
"base64-simd",
"bytes",
"crc-fast",
"hotpath",
"http 1.5.0",
"md-5",
"pretty_assertions",
@@ -9757,7 +9988,6 @@ name = "rustfs-common"
version = "1.0.5"
dependencies = [
"arc-swap",
"hotpath",
"metrics",
"smallvec",
"thiserror 2.0.21",
@@ -9785,7 +10015,6 @@ name = "rustfs-config"
version = "1.0.5"
dependencies = [
"const-str",
"hotpath",
"serde",
"serde_json",
]
@@ -9808,7 +10037,6 @@ version = "1.0.5"
dependencies = [
"base64-simd",
"hmac 0.13.0",
"hotpath",
"rand 0.10.3",
"serde",
"serde_json",
@@ -9824,8 +10052,7 @@ dependencies = [
"argon2",
"base64-simd",
"chacha20poly1305",
"hotpath",
"jsonwebtoken",
"jsonwebtoken 12.0.0",
"pbkdf2 0.13.0",
"rand 0.10.3",
"rsa 0.10.0-rc.18",
@@ -9837,6 +10064,17 @@ dependencies = [
"time",
]
[[package]]
name = "rustfs-cuobject"
version = "1.0.5"
dependencies = [
"bytes",
"cuobject",
"parking_lot 0.13.0",
"thiserror 2.0.21",
"tokio",
]
[[package]]
name = "rustfs-data-usage"
version = "1.0.5"
@@ -9845,6 +10083,7 @@ dependencies = [
"rmp-serde",
"rustfs-filemeta",
"serde",
"serde_json",
]
[[package]]
@@ -9973,14 +10212,14 @@ dependencies = [
[[package]]
name = "rustfs-erasure-codec"
version = "9.0.0"
version = "9.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "10c0115cfe221ffc1e45002a935afc95bce48e01206b642800f0968928bf9b97"
checksum = "d27b3b2484cfd3ca8f444534d96266eae1ac9a87dc658bd093255fe626b4fc6e"
dependencies = [
"cfg_aliases",
"hashlink",
"libm",
"parking_lot 0.12.5",
"parking_lot 0.13.0",
"rayon",
"smallvec",
"spin 0.12.3",
@@ -9990,7 +10229,6 @@ dependencies = [
name = "rustfs-extension-schema"
version = "1.0.5"
dependencies = [
"hotpath",
"serde",
"serde_json",
"thiserror 2.0.21",
@@ -10027,8 +10265,8 @@ dependencies = [
[[package]]
name = "rustfs-gateway"
version = "0.62.0"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
version = "0.63.0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"arc-swap",
"bytes",
@@ -10075,7 +10313,7 @@ dependencies = [
[[package]]
name = "rustfs-gateway-core"
version = "0.60.0"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"bytes",
"futures-core",
@@ -10096,7 +10334,7 @@ dependencies = [
[[package]]
name = "rustfs-gateway-http"
version = "0.1.4"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"hmac 0.13.0",
"http 1.5.0",
@@ -10114,7 +10352,7 @@ dependencies = [
[[package]]
name = "rustfs-gateway-macros"
version = "0.1.4"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"proc-macro2",
"quote",
@@ -10124,7 +10362,7 @@ dependencies = [
[[package]]
name = "rustfs-gateway-sig"
version = "0.15.0"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"hmac 0.13.0",
"http 1.5.0",
@@ -10139,7 +10377,7 @@ dependencies = [
[[package]]
name = "rustfs-gateway-stream"
version = "0.2.0"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"bitflags 2.13.2",
"bytes",
@@ -10150,7 +10388,7 @@ dependencies = [
[[package]]
name = "rustfs-gateway-types"
version = "0.40.0+aws.2026-10-02"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"bytes",
"crc-fast",
@@ -10173,7 +10411,7 @@ dependencies = [
[[package]]
name = "rustfs-gateway-xml"
version = "0.4.0"
source = "git+https://github.com/rustfs/gateway.git?rev=7915d06950f88611d883f6ab3d95efc90c65dec0#7915d06950f88611d883f6ab3d95efc90c65dec0"
source = "git+https://github.com/rustfs/gateway.git?rev=2a6b8d1f7663db978d8784ab3ea331cade19237b#2a6b8d1f7663db978d8784ab3ea331cade19237b"
dependencies = [
"quick-xml 0.41.0",
]
@@ -10241,7 +10479,7 @@ dependencies = [
"hmac 0.13.0",
"hotpath",
"http 1.5.0",
"jsonwebtoken",
"jsonwebtoken 12.0.0",
"moka",
"openidconnect",
"pollster",
@@ -10491,7 +10729,6 @@ version = "1.0.5"
dependencies = [
"chrono",
"flate2",
"hotpath",
"regex",
"serde",
"serde_json",
@@ -10541,6 +10778,20 @@ dependencies = [
"cc",
]
[[package]]
name = "rustfs-nixl"
version = "1.0.5"
dependencies = [
"base64-simd",
"bytes",
"memmap2",
"nixl-sys",
"parking_lot 0.13.0",
"thiserror 2.0.21",
"tokio",
"tracing",
]
[[package]]
name = "rustfs-notify"
version = "1.0.5"
@@ -10601,7 +10852,6 @@ version = "1.0.5"
dependencies = [
"bytes",
"criterion",
"hotpath",
"metrics",
"metrics-util",
"moka",
@@ -10685,7 +10935,7 @@ dependencies = [
"hotpath",
"ipnetwork",
"jiff",
"jsonwebtoken",
"jsonwebtoken 12.0.0",
"moka",
"pollster",
"proptest",
@@ -10778,7 +11028,9 @@ version = "1.0.5"
dependencies = [
"flatbuffers",
"hotpath",
"prost 0.14.5",
"hyper",
"hyper-util",
"prost 0.14.6",
"rcgen",
"rmp-serde",
"rustfs-common",
@@ -10796,6 +11048,7 @@ dependencies = [
"tonic-prost",
"tonic-prost-build",
"tracing",
"tracing-subscriber",
"uuid",
]
@@ -10805,7 +11058,6 @@ version = "1.0.5"
dependencies = [
"byteorder",
"bytes",
"hotpath",
"regex",
"rmp",
"rmp-serde",
@@ -10946,7 +11198,6 @@ version = "1.0.5"
dependencies = [
"bytes",
"futures-core",
"hotpath",
"http 1.5.0",
"http-body",
"http-body-util",
@@ -11037,7 +11288,7 @@ dependencies = [
"metrics",
"opentelemetry-proto",
"opentelemetry_sdk",
"prost 0.14.5",
"prost 0.14.6",
"rand 0.10.3",
"rmp-serde",
"rustfs-common",
@@ -11093,7 +11344,6 @@ dependencies = [
name = "rustfs-security-governance"
version = "1.0.5"
dependencies = [
"hotpath",
"thiserror 2.0.21",
]
@@ -11294,7 +11544,6 @@ dependencies = [
"hex-simd",
"highway",
"hmac 0.13.0",
"hotpath",
"http 1.5.0",
"hyper",
"local-ip-address",
@@ -11392,7 +11641,7 @@ dependencies = [
"errno",
"libc",
"linux-raw-sys",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -11474,7 +11723,7 @@ dependencies = [
"security-framework",
"security-framework-sys",
"webpki-root-certs",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -11485,9 +11734,9 @@ checksum = "eec689c0bc40ff2458a5977b6619cb718087084a18e02a131c599b62d05e1a5f"
[[package]]
name = "rustls-webpki"
version = "0.103.16"
version = "0.103.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281"
checksum = "e3a0760a887c14823fca5a1c970b01d47c328c696c0c64829d1df50e8f853fd5"
dependencies = [
"aws-lc-rs",
"ring",
@@ -12102,6 +12351,12 @@ dependencies = [
"dirs",
]
[[package]]
name = "shlex"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
[[package]]
name = "shlex"
version = "2.0.1"
@@ -12285,7 +12540,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4"
dependencies = [
"libc",
"windows-sys 0.61.2",
"windows-sys 0.60.2",
]
[[package]]
@@ -12436,7 +12691,7 @@ dependencies = [
"cfg-if",
"libc",
"psm",
"windows-sys 0.61.2",
"windows-sys 0.60.2",
]
[[package]]
@@ -12744,10 +12999,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
dependencies = [
"fastrand",
"getrandom 0.4.3",
"getrandom 0.3.4",
"once_cell",
"rustix",
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -13183,7 +13438,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "eba464054e2226f182a34489b8b079bf4c6e3e7ab5fd7fc30e024f24aa92a484"
dependencies = [
"bytes",
"prost 0.14.5",
"prost 0.14.6",
"tonic",
]
@@ -13195,8 +13450,8 @@ checksum = "2ea216ddc448e08e7839ab09e20e60b06b6a1c32745ccb212c0ebd161c199f1b"
dependencies = [
"prettyplease 0.2.37",
"proc-macro2",
"prost-build 0.14.5",
"prost-types 0.14.5",
"prost-build 0.14.6",
"prost-types 0.14.6",
"quote",
"syn 2.0.119",
"tempfile",
@@ -13862,7 +14117,7 @@ version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
dependencies = [
"windows-sys 0.61.2",
"windows-sys 0.52.0",
]
[[package]]
@@ -13871,6 +14126,31 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "wincode"
version = "0.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "063b5affe63fb4e584a33101d8808f01f2348b4f533db6223bf27263a0fdb9e9"
dependencies = [
"pastey",
"proc-macro2",
"quote",
"thiserror 2.0.21",
"wincode-derive",
]
[[package]]
name = "wincode-derive"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "11d582d9fc9d813264407a9e16bfa16846ccf15ef032f9bbcd700741bdc00255"
dependencies = [
"darling 0.23.0",
"proc-macro2",
"quote",
"syn 2.0.119",
]
[[package]]
name = "windows"
version = "0.62.2"
@@ -14516,7 +14796,7 @@ version = "2.1.3+zstd.1.5.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f729a06d0257428fd9d997ac8db7e1407bd0262ab016b085b36bc52957c0052d"
dependencies = [
"bindgen",
"bindgen 0.73.2",
"cc",
"pkg-config",
]
+14 -10
View File
@@ -23,6 +23,8 @@ members = [
"crates/connect-symbol-catalog", # Release-only CPU profile symbol catalog generator
"crates/credentials", # Credential management system
"crates/crypto", # Cryptography and security features
"crates/cuobject", # NVIDIA cuObject S3-over-RDMA staging and transfers (optional)
"crates/nixl", # NIXL/UCX S3-over-RDMA server side (optional)
"crates/ecstore", # Erasure coding storage implementation
"crates/e2e_test", # End-to-end test suite
"crates/filemeta", # File metadata management
@@ -78,7 +80,6 @@ repository = "https://github.com/rustfs/rustfs"
rust-version = "1.99.0"
version = "1.0.5"
homepage = "https://rustfs.com"
description = "RustFS is a high-performance distributed object storage software built using Rust, one of the most popular languages worldwide. "
keywords = ["RustFS", "Minio", "object-storage", "filesystem", "s3"]
categories = ["web-programming", "development-tools", "filesystem", "network-programming"]
authors = ["RustFS Team"]
@@ -93,7 +94,6 @@ redundant_clone = "warn"
[workspace.dependencies]
# RustFS Internal Crates
rustfs = { path = "./rustfs", version = "1.0.5" }
rustfs-gateway-adapter = { path = "crates/gateway-adapter", version = "1.0.5" }
rustfs-heal = { path = "crates/heal", version = "1.0.5" }
rustfs-heal-contracts = { path = "crates/heal-contracts", version = "1.0.5" }
@@ -106,6 +106,8 @@ rustfs-config = { path = "./crates/config", version = "1.0.5" }
rustfs-concurrency = { path = "./crates/concurrency", version = "1.0.5" }
rustfs-credentials = { path = "crates/credentials", version = "1.0.5" }
rustfs-crypto = { path = "crates/crypto", version = "1.0.5" }
rustfs-cuobject = { path = "crates/cuobject", version = "1.0.5" }
rustfs-nixl = { path = "crates/nixl", version = "1.0.5" }
rustfs-ecstore = { path = "crates/ecstore", version = "1.0.5" }
rustfs-filemeta = { path = "crates/filemeta", version = "1.0.5" }
rustfs-iam = { path = "crates/iam", version = "1.0.5" }
@@ -149,14 +151,14 @@ rustfs-zip = { path = "./crates/zip", version = "1.0.5" }
# engine crates move onto from s3s (rustfs/backlog#2745). The one pin of the
# gateway in this workspace; no crate may enable a `compat-s3s*` feature except
# the s3s-facing edge of the rustfs binary.
rustfs-gateway-types = { git = "https://github.com/rustfs/gateway.git", rev = "7915d06950f88611d883f6ab3d95efc90c65dec0", version = "0.40.0", default-features = false }
rustfs-gateway-stream = { git = "https://github.com/rustfs/gateway.git", rev = "7915d06950f88611d883f6ab3d95efc90c65dec0", version = "0.2.0", default-features = false }
rustfs-gateway-types = { git = "https://github.com/rustfs/gateway.git", rev = "2a6b8d1f7663db978d8784ab3ea331cade19237b", version = "0.40.0", default-features = false }
rustfs-gateway-stream = { git = "https://github.com/rustfs/gateway.git", rev = "2a6b8d1f7663db978d8784ab3ea331cade19237b", version = "0.2.0", default-features = false }
# The gateway framework itself, consumed for its extension traits by the ring-2
# adapter. `default-features = false` keeps the `server` feature, and with it the
# server crate, out of the build.
rustfs-gateway = { git = "https://github.com/rustfs/gateway.git", rev = "7915d06950f88611d883f6ab3d95efc90c65dec0", version = "0.62.0", default-features = false }
rustfs-gateway = { git = "https://github.com/rustfs/gateway.git", rev = "2a6b8d1f7663db978d8784ab3ea331cade19237b", version = "0.63.0", default-features = false }
# Test-only: builds the `EffectiveHost` a host-resolution test queries with.
rustfs-gateway-http = { git = "https://github.com/rustfs/gateway.git", rev = "7915d06950f88611d883f6ab3d95efc90c65dec0", default-features = false }
rustfs-gateway-http = { git = "https://github.com/rustfs/gateway.git", rev = "2a6b8d1f7663db978d8784ab3ea331cade19237b", default-features = false }
# Async Runtime and Networking
async-channel = "2.5.0"
@@ -211,7 +213,7 @@ bytesize = "2.7.0"
byteorder = "1.5.0"
flatbuffers = "25.12.19"
form_urlencoded = "1.2.2"
prost = "0.14.5"
prost = "0.14.6"
quick-xml = "0.42.0"
rmp = { version = "0.8.15" }
rmp-serde = { version = "1.3.1" }
@@ -233,7 +235,7 @@ blake2 = "0.11.0"
chacha20poly1305 = { version = "0.11.0" }
crc-fast = "1.10.0"
hmac = { version = "0.13.0" }
jsonwebtoken = { version = "11.1.0" }
jsonwebtoken = { version = "12.0.0" }
openidconnect = { default-features = false, version = "4.1.0" }
pbkdf2 = "0.13.0"
p256 = { version = "0.14.0", features = ["ecdsa", "pkcs8"] }
@@ -306,10 +308,12 @@ hostname = "0.4.2"
ipnetwork = { version = "0.21.1" }
lazy_static = "1.5.1"
libc = "0.2.191"
cuobject = "0.1.0"
libsystemd = "0.7.2"
local-ip-address = "0.6.13"
log = "0.4"
memmap2 = "0.9.12"
nixl-sys = { git = "https://github.com/houseme/nixl", rev = "cc636c83f13d692e85b67e55aed092413d16fb41" }
lz4 = "1.28.1"
lz4_flex = { version = "=0.14.0", default-features = false, features = ["std", "frame"] }
matchit = "0.9.2"
@@ -333,7 +337,7 @@ pretty_assertions = "1.4.1"
rand = { version = "0.10.3" }
ratelimit = "2.0.0"
rayon = "1.12.0"
rustfs-erasure-codec = { version = "9.0.0" }
rustfs-erasure-codec = { version = "9.1.0" }
reed-solomon-simd = "3.1.0"
regex = { version = "1.13.1" }
rumqttc = { package = "rumqttc-next", version = "0.34.0" }
@@ -396,7 +400,7 @@ opentelemetry-stdout = { version = "0.33.1" }
pyroscope = { version = "2.1.5" }
# FTP and SFTP
libunftp = { version = "0.24.0" }
libunftp = { version = "0.25.0" }
unftp-core = "0.1.1"
suppaftp = { version = "12.2.1" }
rcgen = { version = "0.14.10", default-features = false, features = ["aws_lc_rs", "crypto", "pem"] }
+7
View File
@@ -170,10 +170,17 @@ RUN --mount=type=cache,target=/usr/local/cargo/registry \
;; \
esac
# `RC_RELEASE=disabled` is reserved for local server-only validation when the
# GitHub release asset is unavailable. The placeholder fails if invoked, so a
# production image that needs the CLI must keep the default release download.
# TARGETARCH is only provided by BuildKit. Fall back to TARGETPLATFORM (for
# example set by docker-compose) and then to the build host, like the cargo
# step above, so every path that builds this file passes a real architecture.
RUN set -eu; \
if [ "${RC_RELEASE}" = "disabled" ]; then \
install -m 0755 /bin/false /usr/local/bin/rc; \
exit 0; \
fi; \
rc_arch="${TARGETARCH:-}"; \
if [ -z "${rc_arch}" ]; then \
case "${TARGETPLATFORM:-}" in \
+4
View File
@@ -311,6 +311,10 @@ x env use rustfs
rustfs --help
```
### 7\. Docker Swarm with the SwarmCLI chart (Option 7)
Follow the [SwarmCLI chart guide](https://docs.rustfs.com/en/installation/cloud-native/swarmcli-chart) to run RustFS on Docker Swarm, as a single-node service or a distributed, erasure-coded cluster with one peer per node, with the open-source [SwarmCLI `rustfs` chart](https://github.com/Eldara-Tech/swarmcli-charts/tree/main/charts/rustfs). The chart keeps the root credentials in Docker secrets and refuses the default `rustfsadmin` keys, upgrades and rolls back as versioned releases, and can serve the S3 API over HTTPS through Traefik. Its Console stays off until you enable it. The chart and [SwarmCLI](https://github.com/Eldara-Tech/swarmcli) are maintained by Eldara Tech, not by the RustFS project.
---
### Accessing RustFS
+4
View File
@@ -239,6 +239,10 @@ x env use rustfs
rustfs --help
```
### 7\. 使用 SwarmCLI Chart 部署到 Docker Swarm (Option 7)
请按照 [SwarmCLI Chart 指南](https://docs.rustfs.com/zh/installation/cloud-native/swarmcli-chart),使用开源的 [SwarmCLI `rustfs` Chart](https://github.com/Eldara-Tech/swarmcli-charts/tree/main/charts/rustfs) 在 Docker Swarm 上运行 RustFS,可部署为单节点服务,或每个节点一个对等节点、采用纠删码的分布式集群。该 Chart 将 root 凭证保存在 Docker Secret 中并拒绝默认的 `rustfsadmin` 密钥,以带版本的发布进行升级和回滚,并可通过 Traefik 以 HTTPS 提供 S3 API。控制台默认关闭,需要时再启用。该 Chart 和 [SwarmCLI](https://github.com/Eldara-Tech/swarmcli) 由 Eldara Tech 维护,并非 RustFS 项目的一部分。
---
### 访问 RustFS
+3 -4
View File
@@ -30,12 +30,11 @@ workspace = true
[features]
default = []
hotpath = ["hotpath/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
hotpath = []
hotpath-alloc = ["hotpath"]
hotpath-cpu = ["hotpath"]
[dependencies]
hotpath.workspace = true
bytes = { workspace = true, features = ["serde"] }
crc-fast = { workspace = true }
http = { workspace = true }
+3 -4
View File
@@ -30,13 +30,12 @@ workspace = true
[features]
default = []
test-util = []
hotpath = ["hotpath/hotpath", "hotpath/tokio"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
hotpath = []
hotpath-alloc = ["hotpath"]
hotpath-cpu = ["hotpath"]
[dependencies]
arc-swap.workspace = true
hotpath.workspace = true
tokio = { workspace = true, features = ["fs", "rt-multi-thread"] }
tonic = { workspace = true, features = ["gzip", "deflate"] }
uuid = { workspace = true, features = ["v4", "fast-rng", "macro-diagnostics"] }
+157
View File
@@ -23,7 +23,80 @@ pub static GLOBAL_LOCAL_NODE_NAME: LazyLock<RwLock<String>> = LazyLock::new(|| R
pub static GLOBAL_RUSTFS_HOST: LazyLock<RwLock<String>> = LazyLock::new(|| RwLock::new("".to_string()));
pub static GLOBAL_RUSTFS_PORT: LazyLock<RwLock<String>> = LazyLock::new(|| RwLock::new("9000".to_string()));
pub static GLOBAL_RUSTFS_ADDR: LazyLock<RwLock<String>> = LazyLock::new(|| RwLock::new("".to_string()));
static NEXT_GRPC_CHANNEL_ID: AtomicU64 = AtomicU64::new(1);
static NEXT_GRPC_CONNECTION_GENERATION: AtomicU64 = AtomicU64::new(1);
#[derive(Debug)]
struct GrpcConnectionStateInner {
channel_id: u64,
generation: AtomicU64,
}
/// Lock-free identity and physical-connection generation shared by every clone of one gRPC channel.
#[derive(Clone, Debug)]
pub struct GrpcConnectionState(Arc<GrpcConnectionStateInner>);
/// A point-in-time identity for the physical connection currently used by a gRPC channel.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub struct GrpcConnectionSnapshot {
pub channel_id: u64,
pub generation: u64,
}
impl GrpcConnectionState {
pub fn new() -> Self {
Self(Arc::new(GrpcConnectionStateInner {
channel_id: next_nonzero_id(&NEXT_GRPC_CHANNEL_ID),
generation: AtomicU64::new(0),
}))
}
/// Publish a successfully opened physical transport before tonic makes it request-ready.
pub fn record_connected(&self) -> GrpcConnectionSnapshot {
let generation = next_nonzero_id(&NEXT_GRPC_CONNECTION_GENERATION);
self.0.generation.store(generation, Ordering::Release);
GrpcConnectionSnapshot {
channel_id: self.0.channel_id,
generation,
}
}
/// Return `None` until the first physical transport has connected successfully.
pub fn snapshot(&self) -> Option<GrpcConnectionSnapshot> {
let generation = self.0.generation.load(Ordering::Acquire);
(generation != 0).then_some(GrpcConnectionSnapshot {
channel_id: self.0.channel_id,
generation,
})
}
}
impl Default for GrpcConnectionState {
fn default() -> Self {
Self::new()
}
}
fn next_nonzero_id(counter: &AtomicU64) -> u64 {
loop {
let id = counter.fetch_add(1, Ordering::Relaxed);
if id != 0 {
return id;
}
}
}
pub static GLOBAL_CONN_MAP: LazyLock<RwLock<HashMap<String, Channel>>> = LazyLock::new(|| RwLock::new(HashMap::new()));
#[derive(Clone)]
struct TrackedGrpcConnection {
channel: Channel,
connection_state: GrpcConnectionState,
}
static GLOBAL_TRACKED_CONN_MAP: LazyLock<RwLock<HashMap<String, TrackedGrpcConnection>>> =
LazyLock::new(|| RwLock::new(HashMap::new()));
static GLOBAL_CONN_CACHE_WRITER: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
pub static GLOBAL_ROOT_CERT: LazyLock<RwLock<Option<Vec<u8>>>> = LazyLock::new(|| RwLock::new(None));
pub static GLOBAL_MTLS_IDENTITY: LazyLock<RwLock<Option<MtlsIdentityPem>>> = LazyLock::new(|| RwLock::new(None));
pub static GLOBAL_OUTBOUND_TLS_GENERATION: LazyLock<AtomicU64> = LazyLock::new(|| AtomicU64::new(0));
@@ -231,6 +304,16 @@ pub async fn evict_connection(addr: &str) {
/// Evict a stale/dead connection from the global connection cache with an explicit log level.
pub async fn evict_connection_with_log_level(addr: &str, log_level: ConnectionEvictionLogLevel) {
let _ = remove_connection_with_log_level(addr, log_level).await;
}
/// Remove a cached connection and report whether it existed. Transport owners use this to
/// attach a rebuild reason only to real cache transitions.
pub async fn remove_connection_with_log_level(addr: &str, log_level: ConnectionEvictionLogLevel) -> bool {
// Writes are rare and serialized so the optimized tracked cache and public compatibility map
// cannot publish different channel clones for one key.
let _writer = GLOBAL_CONN_CACHE_WRITER.lock().await;
GLOBAL_TRACKED_CONN_MAP.write().await.remove(addr);
let removed = GLOBAL_CONN_MAP.write().await.remove(addr);
if removed.is_some() {
match log_level {
@@ -254,6 +337,7 @@ pub async fn evict_connection_with_log_level(addr: &str, log_level: ConnectionEv
}
}
}
removed.is_some()
}
/// Get a cached gRPC connection for the given address.
@@ -261,8 +345,37 @@ pub async fn cached_connection(addr: &str) -> Option<Channel> {
GLOBAL_CONN_MAP.read().await.get(addr).cloned()
}
/// Get a cached channel together with its shared physical-connection state, when tracked.
pub async fn cached_connection_with_state(addr: &str) -> Option<(Channel, Option<GrpcConnectionState>)> {
if let Some(cached) = GLOBAL_TRACKED_CONN_MAP.read().await.get(addr).cloned() {
return Some((cached.channel, Some(cached.connection_state)));
}
// A miss may race a low-frequency publish/evict. Serialize only this fallback, recheck the
// tracked map, then consult legacy entries injected through the compatibility API.
let _writer = GLOBAL_CONN_CACHE_WRITER.lock().await;
if let Some(cached) = GLOBAL_TRACKED_CONN_MAP.read().await.get(addr).cloned() {
return Some((cached.channel, Some(cached.connection_state)));
}
cached_connection(addr).await.map(|channel| (channel, None))
}
/// Cache a gRPC connection for the given address.
pub async fn cache_connection(addr: String, channel: Channel) {
let _writer = GLOBAL_CONN_CACHE_WRITER.lock().await;
GLOBAL_TRACKED_CONN_MAP.write().await.remove(&addr);
GLOBAL_CONN_MAP.write().await.insert(addr, channel);
}
/// Cache a gRPC channel and its physical-connection state as one coherent entry.
pub async fn cache_connection_with_state(addr: String, channel: Channel, connection_state: GrpcConnectionState) {
let _writer = GLOBAL_CONN_CACHE_WRITER.lock().await;
GLOBAL_TRACKED_CONN_MAP.write().await.insert(
addr.clone(),
TrackedGrpcConnection {
channel: channel.clone(),
connection_state,
},
);
GLOBAL_CONN_MAP.write().await.insert(addr, channel);
}
@@ -279,6 +392,8 @@ pub async fn has_cached_connection(addr: &str) -> bool {
/// Clear all cached connections. Useful for full cluster reset/recovery.
pub async fn clear_all_connections() {
let _writer = GLOBAL_CONN_CACHE_WRITER.lock().await;
GLOBAL_TRACKED_CONN_MAP.write().await.clear();
let mut map = GLOBAL_CONN_MAP.write().await;
let count = map.len();
map.clear();
@@ -363,4 +478,46 @@ mod tls_snapshot_tests {
assert!(!debug.contains("PRIVATE-KEY-MARKER"));
assert!(debug.contains("[REDACTED]"));
}
#[tokio::test]
async fn conditional_connection_removal_preserves_legacy_evict_api() {
let key = "http://conditional-eviction-test.invalid";
cache_connection(
key.to_owned(),
tonic::transport::Endpoint::from_static("http://127.0.0.1:1").connect_lazy(),
)
.await;
assert!(remove_connection_with_log_level(key, ConnectionEvictionLogLevel::Debug).await);
assert!(!remove_connection_with_log_level(key, ConnectionEvictionLogLevel::Debug).await);
let _: () = evict_connection_with_log_level(key, ConnectionEvictionLogLevel::Debug).await;
}
#[tokio::test]
async fn cached_connection_keeps_channel_and_transport_state_coherent() {
let key = "http://tracked-connection-test.invalid";
let channel = tonic::transport::Endpoint::from_static("http://127.0.0.1:1").connect_lazy();
let state = GrpcConnectionState::new();
assert!(state.snapshot().is_none());
let first = state.record_connected();
cache_connection_with_state(key.to_owned(), channel, state.clone()).await;
let (_, cached_state) = cached_connection_with_state(key).await.expect("tracked cache entry");
let cached_state = cached_state.expect("tracked cache state");
assert_eq!(cached_state.snapshot(), Some(first));
let second = state.record_connected();
assert_eq!(cached_state.snapshot(), Some(second));
assert_eq!(first.channel_id, second.channel_id);
assert_ne!(first.generation, second.generation);
cache_connection(
key.to_owned(),
tonic::transport::Endpoint::from_static("http://127.0.0.1:2").connect_lazy(),
)
.await;
let (_, replacement_state) = cached_connection_with_state(key).await.expect("legacy replacement entry");
assert!(replacement_state.is_none(), "legacy replacement must remove stale tracked state");
assert!(remove_connection_with_log_level(key, ConnectionEvictionLogLevel::Debug).await);
assert!(cached_connection_with_state(key).await.is_none());
}
}
+3 -4
View File
@@ -25,7 +25,6 @@ keywords = ["configuration", "settings", "management", "rustfs", "Minio"]
categories = ["web-programming", "development-tools", "config"]
[dependencies]
hotpath.workspace = true
const-str = { workspace = true, optional = true, features = ["std", "proc"] }
serde = { workspace = true, optional = true, features = ["derive"] }
serde_json = { workspace = true, optional = true, features = ["raw_value"] }
@@ -35,9 +34,9 @@ workspace = true
[features]
default = ["constants"]
hotpath = ["hotpath/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
hotpath = []
hotpath-alloc = ["hotpath"]
hotpath-cpu = ["hotpath"]
audit = ["dep:const-str", "constants"]
constants = ["dep:const-str"]
notify = ["dep:const-str", "constants"]
+11
View File
@@ -121,6 +121,11 @@ when restoring `/rustfs/console` for a custom OEM build.
- `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` (canonical)
- `RUSTFS_SCANNER_CYCLE_MAX_OBJECTS` (canonical)
- `RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES` (canonical)
- `RUSTFS_SCANNER_BUCKET_QUANTUM_DURATION_SECS` (canonical)
- `RUSTFS_SCANNER_BUCKET_QUANTUM_OBJECTS` (canonical)
- `RUSTFS_SCANNER_BUCKET_QUANTUM_DIRECTORIES` (canonical)
- `RUSTFS_SCANNER_BUCKET_QUANTUM_ENTRIES` (canonical)
- `RUSTFS_SCANNER_BUCKET_QUANTUM_NAME_BYTES` (canonical)
- `RUSTFS_SCANNER_MAX_CONCURRENT_SET_SCANS` (canonical)
- `RUSTFS_SCANNER_MAX_CONCURRENT_DISK_SCANS` (canonical)
- `RUSTFS_SCANNER_WALKERS_PER_DISK` (canonical)
@@ -130,6 +135,12 @@ Scanner cycle budget controls:
- When `RUSTFS_SCANNER_CYCLE_MAX_DURATION_SECS` is unset, the finite default is 1800 seconds (30 minutes), matching the scanner benchmark guidance.
- An explicit `0` preserves the compatibility behavior of an unbounded runtime budget. Object and directory budgets likewise remain unbounded when explicitly set to `0`.
Scanner bucket quantum controls:
- `RUSTFS_SCANNER_BUCKET_QUANTUM_DURATION_SECS`, `RUSTFS_SCANNER_BUCKET_QUANTUM_OBJECTS`, `RUSTFS_SCANNER_BUCKET_QUANTUM_DIRECTORIES`, `RUSTFS_SCANNER_BUCKET_QUANTUM_ENTRIES`, and `RUSTFS_SCANNER_BUCKET_QUANTUM_NAME_BYTES` cap one bucket admission. Their persistent keys are `scanner.bucket_quantum_duration`, `scanner.bucket_quantum_objects`, `scanner.bucket_quantum_directories`, `scanner.bucket_quantum_entries`, and `scanner.bucket_quantum_name_bytes`; duration is in whole seconds and the remaining keys are work counts or bytes.
- All five defaults are `0` for controlled rollout. A positive value enables that dimension; `0` disables that dimension, and all five zero values disable the bucket quantum. Parent cycle limits remain in force. Invalid unsigned integers and durations outside the platform timer range are rejected; environment overrides take precedence but cannot hide invalid persisted values. Admin scanner status reports each effective value and source under `runtime_config.bucket_quantum_*`, using `bucket_quantum_duration_seconds` for duration.
- Disabled defaults are an initial rollout state, not completion of usage-convergence acceptance. Production defaults require matched-topology A/B measurements and the remote progress/fairness checks in [Scanner runtime controls](../../docs/operations/scanner-runtime-controls.md#bucket-quantum-rollout-and-acceptance). These controls do not certify partial usage or acknowledge pending dirty work.
Scanner recovery retry controls:
- `RUSTFS_SCANNER_RECOVERY_BACKOFF_CAP_SECS` caps the wait between automatic startup recovery retries. The persistent admin key is `scanner.recovery_backoff_cap`; the environment takes precedence over the persistent value, and the unset default remains 600 seconds (10 minutes). Values must be positive integer seconds within the platform timer range; `0`, malformed values, and overflow are rejected. A valid environment override does not hide an invalid persistent value from `admin config set` validation.
+2 -2
View File
@@ -35,8 +35,8 @@ pub const DEFAULT_HEALTH_OBJECT_PROGRESS_TIMEOUT_MS: u64 = 30_000;
/// Additional time beyond the configured object-lock acquisition deadline.
pub const HEALTH_OBJECT_PROGRESS_LOCK_MARGIN_MS: u64 = 5_000;
/// Timeout for cluster health readiness collectors (milliseconds).
/// This bounds expensive storage and lock quorum checks used by cluster probes.
/// End-to-end budget for cluster health readiness probes (milliseconds).
/// Includes cache/singleflight waiting, storage observations, and lock checks.
pub const ENV_HEALTH_CLUSTER_TIMEOUT_MS: &str = "RUSTFS_HEALTH_CLUSTER_TIMEOUT_MS";
pub const DEFAULT_HEALTH_CLUSTER_TIMEOUT_MS: u64 = 2000;
+145 -2
View File
@@ -121,9 +121,17 @@ pub const DEFAULT_INTERNODE_RPC_MSGPACK_ONLY: bool = false;
pub const ENV_INTERNODE_RPC_MSGPACK_ONLY_FLEET_CONFIRMED: &str = "RUSTFS_INTERNODE_RPC_MSGPACK_ONLY_FLEET_CONFIRMED";
pub const DEFAULT_INTERNODE_RPC_MSGPACK_ONLY_FLEET_CONFIRMED: bool = false;
/// Permit current per-peer capability proof to replace fleet-wide confirmation.
///
/// This remains ineffective unless [`ENV_INTERNODE_RPC_MSGPACK_ONLY`] is also enabled. Unknown,
/// unsupported, revoked, or stale connection generations keep dual-writing JSON.
pub const ENV_INTERNODE_RPC_MSGPACK_PEER_CAPABILITY: &str = "RUSTFS_INTERNODE_RPC_MSGPACK_PEER_CAPABILITY";
pub const DEFAULT_INTERNODE_RPC_MSGPACK_PEER_CAPABILITY: bool = false;
// Compile-time invariants: dual-write by default so the base build is byte-for-byte legacy behavior.
const _: () = assert!(!DEFAULT_INTERNODE_RPC_MSGPACK_ONLY);
const _: () = assert!(!DEFAULT_INTERNODE_RPC_MSGPACK_ONLY_FLEET_CONFIRMED);
const _: () = assert!(!DEFAULT_INTERNODE_RPC_MSGPACK_PEER_CAPABILITY);
/// Require target-bound v2 signatures on every internode gRPC request, rejecting the legacy
/// constant-target fallback instead of accepting it (<https://github.com/rustfs/backlog/issues/1327>).
@@ -294,6 +302,14 @@ pub const DEFAULT_INTERNODE_BULK_CONCURRENCY_LIMIT: usize = 64;
pub const ENV_INTERNODE_BULK_BUFFER_SIZE: &str = "RUSTFS_INTERNODE_BULK_BUFFER_SIZE";
pub const DEFAULT_INTERNODE_BULK_BUFFER_SIZE: usize = 1024;
/// Per-peer limit held through complete bulk-unary response decoding and validation. Zero keeps
/// the compatibility behavior with no additional admission gate.
pub const ENV_INTERNODE_BULK_BODY_CONCURRENCY_LIMIT: &str = "RUSTFS_INTERNODE_BULK_BODY_CONCURRENCY_LIMIT";
pub const DEFAULT_INTERNODE_BULK_BODY_CONCURRENCY_LIMIT: usize = 0;
pub const ENV_INTERNODE_BULK_BODY_WAIT_TIMEOUT_MS: &str = "RUSTFS_INTERNODE_BULK_BODY_WAIT_TIMEOUT_MS";
pub const DEFAULT_INTERNODE_BULK_BODY_WAIT_TIMEOUT_MS: u64 = 1_000;
const _: () = assert!(DEFAULT_INTERNODE_BULK_BODY_CONCURRENCY_LIMIT == 0);
/// Profile selector for conservative internode HTTP data-plane client tuning.
pub const ENV_INTERNODE_HTTP_TUNING_PROFILE: &str = "RUSTFS_INTERNODE_HTTP_TUNING_PROFILE";
pub const DEFAULT_INTERNODE_HTTP_TUNING_PROFILE: &str = "legacy";
@@ -333,8 +349,130 @@ pub const DEFAULT_INTERNODE_DATA_TRANSPORT: &str = "tcp-http";
/// Legacy alias for "tcp-http". Both values select the TCP/HTTP transport backend.
pub const INTERNODE_DATA_TRANSPORT_TCP: &str = "tcp";
/// Internode reads whose data moves over NIXL/UCX (InfiniBand rails or RoCE by
/// LID/GID, no IP needed); requests, writes and walks stay on TCP/HTTP. Requires
/// a binary built with the `nixl` feature and `RUSTFS_NIXL_ENABLE`; until the
/// NIXL agent is up, and for any read it cannot serve, it uses TCP/HTTP.
pub const INTERNODE_DATA_TRANSPORT_NIXL: &str = "nixl";
/// Known internode transport backend names accepted by the config parser.
pub const KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS: &[&str] = &[DEFAULT_INTERNODE_DATA_TRANSPORT, INTERNODE_DATA_TRANSPORT_TCP];
pub const KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS: &[&str] = &[
DEFAULT_INTERNODE_DATA_TRANSPORT,
INTERNODE_DATA_TRANSPORT_TCP,
INTERNODE_DATA_TRANSPORT_NIXL,
];
/// Check the configured RDMA devices at startup and leave out any that is down,
/// slower than its peers, or loses its link during a short watch.
pub const ENV_RUSTFS_NIXL_DEVICE_CHECK: &str = "RUSTFS_NIXL_DEVICE_CHECK";
pub const DEFAULT_RUSTFS_NIXL_DEVICE_CHECK: bool = true;
/// Leave out a device whose link dropped this many times more since boot than
/// the quietest device of its link layer; 0 skips this test.
pub const ENV_RUSTFS_NIXL_DEVICE_MAX_LINK_DROPS: &str = "RUSTFS_NIXL_DEVICE_MAX_LINK_DROPS";
pub const DEFAULT_RUSTFS_NIXL_DEVICE_MAX_LINK_DROPS: u64 = 16;
/// How long the startup device check watches the link counters; 0 skips the watch.
pub const ENV_RUSTFS_NIXL_DEVICE_FLAP_WINDOW_MS: &str = "RUSTFS_NIXL_DEVICE_FLAP_WINDOW_MS";
pub const DEFAULT_RUSTFS_NIXL_DEVICE_FLAP_WINDOW_MS: u64 = 3_000;
/// NIXL internode reads in flight per remote shard stream.
pub const ENV_RUSTFS_NIXL_INTERNODE_DEPTH: &str = "RUSTFS_NIXL_INTERNODE_DEPTH";
pub const DEFAULT_RUSTFS_NIXL_INTERNODE_DEPTH: usize = 4;
/// Whether S3 GETs and PUTs carrying the NIXL headers are served over NIXL/UCX
/// S3-over-RDMA (requires a build with the `nixl` feature and libnixl). The
/// pipeline settings below (`RUSTFS_CUOBJECT_GET_FANOUT*`, `_INFLIGHT_WRITES`,
/// `_SHARD_ARENA_BYTES`) apply to this transport as well.
pub const ENV_RUSTFS_NIXL_ENABLE: &str = "RUSTFS_NIXL_ENABLE";
pub const DEFAULT_RUSTFS_NIXL_ENABLE: bool = false;
/// This node's NIXL agent name; defaults to `rustfs-<first local endpoint host>`.
pub const ENV_RUSTFS_NIXL_AGENT_NAME: &str = "RUSTFS_NIXL_AGENT_NAME";
/// Comma-separated UCX device names (`mlx5_9,mlx5_10`; NIXL adds the port); empty lets UCX use every device.
pub const ENV_RUSTFS_NIXL_UCX_DEVICES: &str = "RUSTFS_NIXL_UCX_DEVICES";
/// UCX progress workers of the agent.
pub const ENV_RUSTFS_NIXL_NUM_WORKERS: &str = "RUSTFS_NIXL_NUM_WORKERS";
pub const DEFAULT_RUSTFS_NIXL_NUM_WORKERS: u32 = 1;
/// Staging chunk size per transfer descriptor to a client.
pub const ENV_RUSTFS_NIXL_CHUNK_BYTES: &str = "RUSTFS_NIXL_CHUNK_BYTES";
pub const DEFAULT_RUSTFS_NIXL_CHUNK_BYTES: usize = 16 * 1024 * 1024;
/// Registered staging memory of the agent.
pub const ENV_RUSTFS_NIXL_POOL_BYTES: &str = "RUSTFS_NIXL_POOL_BYTES";
pub const DEFAULT_RUSTFS_NIXL_POOL_BYTES: usize = 1024 * 1024 * 1024;
/// Transfers in flight per node at most.
pub const ENV_RUSTFS_NIXL_MAX_INFLIGHT: &str = "RUSTFS_NIXL_MAX_INFLIGHT";
pub const DEFAULT_RUSTFS_NIXL_MAX_INFLIGHT: usize = 256;
/// A transfer that has not completed after this many seconds fails the request.
pub const ENV_RUSTFS_NIXL_TRANSFER_TIMEOUT_SECS: &str = "RUSTFS_NIXL_TRANSFER_TIMEOUT_SECS";
pub const DEFAULT_RUSTFS_NIXL_TRANSFER_TIMEOUT_SECS: u64 = 60;
/// Whether S3 GETs carrying an `x-amz-rdma-token` are served over cuObject S3-over-RDMA
/// (requires a build with the `cuobject` feature and libcuobjserver).
pub const ENV_RUSTFS_CUOBJECT_ENABLE: &str = "RUSTFS_CUOBJECT_ENABLE";
pub const DEFAULT_RUSTFS_CUOBJECT_ENABLE: bool = false;
/// Comma-separated RDMA-capable IP addresses that get a cuObject server each.
/// Defaults to the hosts of this node's own endpoints.
pub const ENV_RUSTFS_CUOBJECT_ADDRS: &str = "RUSTFS_CUOBJECT_ADDRS";
/// UDP/RDMA control port of the cuObject servers.
pub const ENV_RUSTFS_CUOBJECT_PORT: &str = "RUSTFS_CUOBJECT_PORT";
pub const DEFAULT_RUSTFS_CUOBJECT_PORT: u16 = 18515;
/// Staging chunk size per RDMA write to a client.
pub const ENV_RUSTFS_CUOBJECT_CHUNK_BYTES: &str = "RUSTFS_CUOBJECT_CHUNK_BYTES";
pub const DEFAULT_RUSTFS_CUOBJECT_CHUNK_BYTES: usize = 16 * 1024 * 1024;
/// Registered staging memory per cuObject server.
pub const ENV_RUSTFS_CUOBJECT_POOL_BYTES: &str = "RUSTFS_CUOBJECT_POOL_BYTES";
pub const DEFAULT_RUSTFS_CUOBJECT_POOL_BYTES: usize = 1024 * 1024 * 1024;
/// Dynamically connected initiators per cuObject server (concurrent client connections).
/// Staging chunks (RDMA writes) kept in flight per GET, so decoding never waits
/// for the write of the previous chunk; each costs one chunk of the pool.
pub const ENV_RUSTFS_CUOBJECT_INFLIGHT_WRITES: &str = "RUSTFS_CUOBJECT_INFLIGHT_WRITES";
pub const DEFAULT_RUSTFS_CUOBJECT_INFLIGHT_WRITES: usize = 3;
/// Staging chunks (RDMA reads from the client buffer) kept in flight per
/// RDMA PUT body, so ingest never waits on one chunk's round trip at a time;
/// each costs one chunk of the pool.
pub const ENV_RUSTFS_CUOBJECT_PUT_READ_AHEAD: &str = "RUSTFS_CUOBJECT_PUT_READ_AHEAD";
pub const DEFAULT_RUSTFS_CUOBJECT_PUT_READ_AHEAD: usize = 4;
/// Concurrent erasure-block-aligned segments one cuObject GET is split into
/// on the server (each segment decodes and RDMA-writes its own stripes), so a
/// single stream keeps several stripes in flight. 1 disables the fan-out.
pub const ENV_RUSTFS_CUOBJECT_GET_FANOUT: &str = "RUSTFS_CUOBJECT_GET_FANOUT";
pub const DEFAULT_RUSTFS_CUOBJECT_GET_FANOUT: usize = 8;
/// Smallest segment worth its own producer (rounded up to whole erasure
/// blocks): each segment pays a reader setup per part it touches, so short
/// requests stay sequential.
pub const ENV_RUSTFS_CUOBJECT_GET_FANOUT_MIN_BYTES: &str = "RUSTFS_CUOBJECT_GET_FANOUT_MIN_BYTES";
pub const DEFAULT_RUSTFS_CUOBJECT_GET_FANOUT_MIN_BYTES: u64 = 192 * 1024 * 1024;
/// Segment producers a node runs across all its cuObject GETs: each new GET
/// gets a fair share (budget / open GETs, at least 1, at most the fan-out)
/// and never waits for one, so many-stream load degrades to sequential GETs
/// instead of a reader-setup storm.
pub const ENV_RUSTFS_CUOBJECT_GET_FANOUT_BUDGET: &str = "RUSTFS_CUOBJECT_GET_FANOUT_BUDGET";
pub const DEFAULT_RUSTFS_CUOBJECT_GET_FANOUT_BUDGET: usize = 16;
/// Registered host memory the erasure decoder reads shards into so a
/// cuObject GET can RDMA-write data shards straight from those buffers
/// (zero-copy emit); 0 keeps the staging copy. Blocks are
/// `RUSTFS_ERASURE_SHARD_BYTES` (4 MiB when unset); objects with larger
/// shards fall back to heap buffers and the staging copy.
pub const ENV_RUSTFS_CUOBJECT_SHARD_ARENA_BYTES: &str = "RUSTFS_CUOBJECT_SHARD_ARENA_BYTES";
pub const DEFAULT_RUSTFS_CUOBJECT_SHARD_ARENA_BYTES: usize = 0;
pub const ENV_RUSTFS_CUOBJECT_NUM_DCIS: &str = "RUSTFS_CUOBJECT_NUM_DCIS";
pub const DEFAULT_RUSTFS_CUOBJECT_NUM_DCIS: u32 = 128;
/// Complete cuObject transfers through the library's asynchronous mode: the
/// write is submitted with a handle and the task waits on the channel's
/// completion descriptor instead of holding a blocking thread for the whole
/// transfer. `false` keeps one blocking library call per transfer.
pub const ENV_RUSTFS_CUOBJECT_ASYNC_TRANSFERS: &str = "RUSTFS_CUOBJECT_ASYNC_TRANSFERS";
pub const DEFAULT_RUSTFS_CUOBJECT_ASYNC_TRANSFERS: bool = true;
#[cfg(test)]
mod tests {
@@ -379,8 +517,12 @@ mod tests {
fn internode_channel_isolation_defaults_and_env_names() {
// The isolation-off default is asserted at compile time next to the constant definition.
assert_eq!(DEFAULT_INTERNODE_BULK_CHANNELS, 2);
assert_eq!(DEFAULT_INTERNODE_BULK_BODY_CONCURRENCY_LIMIT, 0);
assert_eq!(DEFAULT_INTERNODE_BULK_BODY_WAIT_TIMEOUT_MS, 1_000);
assert_eq!(ENV_INTERNODE_CHANNEL_ISOLATION, "RUSTFS_INTERNODE_CHANNEL_ISOLATION");
assert_eq!(ENV_INTERNODE_BULK_CHANNELS, "RUSTFS_INTERNODE_BULK_CHANNELS");
assert_eq!(ENV_INTERNODE_BULK_BODY_CONCURRENCY_LIMIT, "RUSTFS_INTERNODE_BULK_BODY_CONCURRENCY_LIMIT");
assert_eq!(ENV_INTERNODE_BULK_BODY_WAIT_TIMEOUT_MS, "RUSTFS_INTERNODE_BULK_BODY_WAIT_TIMEOUT_MS");
}
#[test]
@@ -391,6 +533,7 @@ mod tests {
ENV_INTERNODE_RPC_MSGPACK_ONLY_FLEET_CONFIRMED,
"RUSTFS_INTERNODE_RPC_MSGPACK_ONLY_FLEET_CONFIRMED"
);
assert_eq!(ENV_INTERNODE_RPC_MSGPACK_PEER_CAPABILITY, "RUSTFS_INTERNODE_RPC_MSGPACK_PEER_CAPABILITY");
}
#[test]
@@ -465,6 +608,6 @@ mod tests {
assert_eq!(ENV_RUSTFS_INTERNODE_DATA_TRANSPORT, "RUSTFS_INTERNODE_DATA_TRANSPORT");
assert_eq!(DEFAULT_INTERNODE_DATA_TRANSPORT, "tcp-http");
assert_eq!(INTERNODE_DATA_TRANSPORT_TCP, "tcp");
assert_eq!(KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS, &["tcp-http", "tcp"]);
assert_eq!(KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS, &["tcp-http", "tcp", "nixl"]);
}
}
+50
View File
@@ -44,6 +44,21 @@ pub const SCANNER_CYCLE_MAX_OBJECTS: &str = "cycle_max_objects";
/// Scanner config key capping directories entered by one cycle.
pub const SCANNER_CYCLE_MAX_DIRECTORIES: &str = "cycle_max_directories";
/// Per-bucket admission limit in seconds; zero disables this dimension.
pub const SCANNER_BUCKET_QUANTUM_DURATION: &str = "bucket_quantum_duration";
/// Per-bucket admission limit in objects; zero disables this dimension.
pub const SCANNER_BUCKET_QUANTUM_OBJECTS: &str = "bucket_quantum_objects";
/// Per-bucket admission limit in directories; zero disables this dimension.
pub const SCANNER_BUCKET_QUANTUM_DIRECTORIES: &str = "bucket_quantum_directories";
/// Per-bucket admission limit in raw entries; zero disables this dimension.
pub const SCANNER_BUCKET_QUANTUM_ENTRIES: &str = "bucket_quantum_entries";
/// Per-bucket admission limit in raw entry-name bytes; zero disables this dimension.
pub const SCANNER_BUCKET_QUANTUM_NAME_BYTES: &str = "bucket_quantum_name_bytes";
/// Scanner config key setting the periodic bitrot scan cycle in seconds.
pub const SCANNER_BITROT_CYCLE: &str = "bitrot_cycle";
@@ -93,6 +108,11 @@ pub const SCANNER_KEYS: &[&str] = &[
SCANNER_CYCLE_MAX_DURATION,
SCANNER_CYCLE_MAX_OBJECTS,
SCANNER_CYCLE_MAX_DIRECTORIES,
SCANNER_BUCKET_QUANTUM_DURATION,
SCANNER_BUCKET_QUANTUM_OBJECTS,
SCANNER_BUCKET_QUANTUM_DIRECTORIES,
SCANNER_BUCKET_QUANTUM_ENTRIES,
SCANNER_BUCKET_QUANTUM_NAME_BYTES,
SCANNER_BITROT_CYCLE,
SCANNER_IDLE_MODE,
SCANNER_CACHE_SAVE_TIMEOUT,
@@ -141,6 +161,36 @@ pub const ENV_SCANNER_CYCLE_MAX_OBJECTS: &str = "RUSTFS_SCANNER_CYCLE_MAX_OBJECT
/// - Example: `export RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES=100000`
pub const ENV_SCANNER_CYCLE_MAX_DIRECTORIES: &str = "RUSTFS_SCANNER_CYCLE_MAX_DIRECTORIES";
/// Per-bucket admission limit in seconds; zero disables this dimension.
pub const ENV_SCANNER_BUCKET_QUANTUM_DURATION_SECS: &str = "RUSTFS_SCANNER_BUCKET_QUANTUM_DURATION_SECS";
/// Disabled until controlled-fleet acceptance selects production limits.
pub const DEFAULT_SCANNER_BUCKET_QUANTUM_DURATION_SECS: u64 = 0;
/// Per-bucket admission limit in objects; zero disables this dimension.
pub const ENV_SCANNER_BUCKET_QUANTUM_OBJECTS: &str = "RUSTFS_SCANNER_BUCKET_QUANTUM_OBJECTS";
/// Disabled until controlled-fleet acceptance selects production limits.
pub const DEFAULT_SCANNER_BUCKET_QUANTUM_OBJECTS: u64 = 0;
/// Per-bucket admission limit in directories; zero disables this dimension.
pub const ENV_SCANNER_BUCKET_QUANTUM_DIRECTORIES: &str = "RUSTFS_SCANNER_BUCKET_QUANTUM_DIRECTORIES";
/// Disabled until controlled-fleet acceptance selects production limits.
pub const DEFAULT_SCANNER_BUCKET_QUANTUM_DIRECTORIES: u64 = 0;
/// Per-bucket admission limit in raw entries; zero disables this dimension.
pub const ENV_SCANNER_BUCKET_QUANTUM_ENTRIES: &str = "RUSTFS_SCANNER_BUCKET_QUANTUM_ENTRIES";
/// Disabled until controlled-fleet acceptance selects production limits.
pub const DEFAULT_SCANNER_BUCKET_QUANTUM_ENTRIES: u64 = 0;
/// Per-bucket admission limit in raw entry-name bytes; zero disables this dimension.
pub const ENV_SCANNER_BUCKET_QUANTUM_NAME_BYTES: &str = "RUSTFS_SCANNER_BUCKET_QUANTUM_NAME_BYTES";
/// Disabled until controlled-fleet acceptance selects production limits.
pub const DEFAULT_SCANNER_BUCKET_QUANTUM_NAME_BYTES: u64 = 0;
/// Environment variable that selects the scanner speed preset.
/// Valid values: `fastest`, `fast`, `default`, `slow`, `slowest`.
/// Controls the sleep factor, maximum sleep duration, and cycle interval.
+3 -4
View File
@@ -26,12 +26,11 @@ categories = ["web-programming", "development-tools", "data-structures", "securi
[features]
default = []
hotpath = ["hotpath/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
hotpath = []
hotpath-alloc = ["hotpath"]
hotpath-cpu = ["hotpath"]
[dependencies]
hotpath.workspace = true
base64-simd = { workspace = true }
hmac = { workspace = true }
rand = { workspace = true, features = ["serde"] }
+3 -4
View File
@@ -29,7 +29,6 @@ documentation = "https://docs.rs/rustfs-crypto/latest/rustfs_crypto/"
workspace = true
[dependencies]
hotpath.workspace = true
aes-gcm = { workspace = true, optional = true, features = ["rand_core"] }
argon2 = { workspace = true, optional = true }
chacha20poly1305 = { workspace = true, optional = true }
@@ -50,9 +49,9 @@ time = { workspace = true, features = ["parsing", "formatting", "macros", "serde
[features]
default = ["crypto", "fips"]
hotpath = ["hotpath/hotpath"]
hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
hotpath = []
hotpath-alloc = ["hotpath"]
hotpath-cpu = ["hotpath"]
fips = []
crypto = [
"dep:aes-gcm",
+2 -5
View File
@@ -18,9 +18,6 @@ use crate::Error;
use crate::jwt::Claims;
pub fn decode(token: &str, token_secret: &[u8]) -> Result<TokenData<Claims>, Error> {
Ok(jsonwebtoken::decode(
token,
&DecodingKey::from_secret(token_secret),
&Validation::new(Algorithm::HS512),
)?)
let key = DecodingKey::from_secret(token_secret)?;
Ok(jsonwebtoken::decode(token, &key, &Validation::new(Algorithm::HS512))?)
}
+2 -5
View File
@@ -18,9 +18,6 @@ use crate::Error;
use crate::jwt::Claims;
pub fn encode(token_secret: &[u8], claims: &Claims) -> Result<String, Error> {
Ok(jsonwebtoken::encode(
&Header::new(Algorithm::HS512),
claims,
&EncodingKey::from_secret(token_secret),
)?)
let key = EncodingKey::from_secret(token_secret)?;
Ok(jsonwebtoken::encode(&Header::new(Algorithm::HS512), claims, &key)?)
}
+26
View File
@@ -0,0 +1,26 @@
[package]
name = "rustfs-cuobject"
edition.workspace = true
license.workspace = true
repository.workspace = true
rust-version.workspace = true
version.workspace = true
homepage.workspace = true
description = "RustFS staging pool and transfers for NVIDIA cuObject S3-over-RDMA (GPUDirect object loading)"
keywords = ["rdma", "cuobject", "gpudirect", "s3"]
categories = ["network-programming"]
documentation = "https://docs.rs/rustfs-cuobject/latest/rustfs_cuobject/"
[lints]
workspace = true
[dependencies]
bytes = { workspace = true, optional = true }
cuobject = { workspace = true, default-features = false, optional = true }
parking_lot = { workspace = true, optional = true }
thiserror = { workspace = true, optional = true }
tokio = { workspace = true, features = ["net", "rt-multi-thread", "sync", "time"], optional = true }
[features]
# Compiles the cuObject server bindings (needs the NVIDIA cuObject SDK).
server = ["dep:bytes", "dep:cuobject", "cuobject/server", "dep:parking_lot", "dep:thiserror", "dep:tokio"]
+775
View File
@@ -0,0 +1,775 @@
// 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.
//! Server side of NVIDIA cuObject S3-over-RDMA.
//!
//! A client that supports the protocol (NVIDIA cuObject, NIXL's object plugin,
//! …) sends an ordinary S3 GET with an `x-amz-rdma-token` header describing a
//! registered client buffer (host or GPU memory). Instead of streaming the
//! body over HTTP, the server RDMA-writes the object bytes into that buffer
//! through NVIDIA's `libcuobjserver` and answers with an empty body plus
//! `x-amz-rdma-reply` and `x-amz-rdma-bytes-transferred`.
//!
//! The library bindings come from the [`cuobject`] crate. This crate owns
//! RustFS's pool of registered, page-aligned host staging buffers: the regular
//! read path fills a staging chunk and
//! [`CuObjectServer::write_to_client_owned`] pushes it.
//!
//! Everything below needs the `server` feature, which compiles the
//! NVIDIA cuObject server bindings; without it the crate is empty, so a
//! workspace build does not need the cuObject SDK.
#![cfg(feature = "server")]
use bytes::Bytes;
use cuobject::{Channel, Completion, RegisteredBuffer, Server, ServerOptions, SgBuffer, SgEntry, Source};
use std::collections::VecDeque;
use std::net::IpAddr;
use std::num::NonZeroUsize;
use std::sync::Arc;
use std::time::Duration;
use thiserror::Error;
use tokio::io::Interest;
use tokio::io::unix::AsyncFd;
use tokio::sync::Semaphore;
/// Header carrying the client's RDMA descriptor on a request.
pub const RDMA_TOKEN_HEADER: &str = cuobject::TOKEN_HEADER;
/// Header carrying the transfer status on the response (HTTP-style code).
pub const RDMA_REPLY_HEADER: &str = cuobject::REPLY_HEADER;
/// Header carrying the payload byte count moved over RDMA.
pub const RDMA_BYTES_TRANSFERRED_HEADER: &str = cuobject::BYTES_TRANSFERRED_HEADER;
/// Reply code for a declined transfer (the client then errors or falls back).
pub const RDMA_REPLY_NOT_IMPLEMENTED: u16 = cuobject::REPLY_NOT_IMPLEMENTED;
/// Largest single `handleGetObject` the library accepts.
pub const MAX_RDMA_OP_BYTES: usize = cuobject::MAX_TRANSFER_BYTES;
/// Default RDMA control port of the cuObject server.
pub const DEFAULT_PORT: u16 = cuobject::DEFAULT_PORT;
/// Most ranges one scatter-gather transfer may carry (the library's `max_sge`).
pub const MAX_SG_RANGES: usize = cuobject::DEFAULT_MAX_SG_ENTRIES;
/// Version of the cuObject server headers the bindings were built against, as
/// (major, minor).
pub fn library_version() -> (u32, u32) {
cuobject::header_version()
}
#[derive(Debug, Error)]
pub enum CuObjectError {
#[error("cuobject {op} failed: {source}")]
Os {
op: &'static str,
#[source]
source: std::io::Error,
},
#[error("cuobject rdma token is malformed: {0}")]
Token(String),
#[error("cuobject rdma token buffer ({buffer} bytes) is smaller than the response ({needed} bytes)")]
TokenTooSmall { buffer: u64, needed: u64 },
#[error("cuobject rejected the request: {0}")]
Invalid(&'static str),
#[error("cuobject transfer failed with verbs status {verbs_status}: {source}")]
Transfer {
verbs_status: i32,
#[source]
source: std::io::Error,
},
#[error("cuobject transfer moved {moved} of {expected} bytes")]
ShortTransfer { moved: u64, expected: u64 },
#[error("cuobject staging pool exhausted")]
PoolExhausted,
#[error("cuobject library offers no completion descriptor for channel {0}")]
AsyncUnavailable(u16),
#[error("cuobject read source failed: {0}")]
Source(#[source] std::io::Error),
}
impl From<cuobject::Error> for CuObjectError {
fn from(error: cuobject::Error) -> Self {
match error {
cuobject::Error::Library { op, source } => Self::Os { op, source },
cuobject::Error::Transfer { verbs_status, source } => Self::Transfer { verbs_status, source },
cuobject::Error::InvalidArgument(reason) => Self::Invalid(reason),
cuobject::Error::InvalidToken(reason) => Self::Token(reason.to_owned()),
cuobject::Error::TokenTooSmall { buffer, needed } => Self::TokenTooSmall { buffer, needed },
cuobject::Error::AsyncUnavailable(channel) => Self::AsyncUnavailable(channel),
other => Self::Os {
op: "cuobject",
source: std::io::Error::other(other),
},
}
}
}
/// Parsed `x-amz-rdma-token`.
///
/// Wire format (cuObject RDMA descriptor protocol): colon-separated hex
/// fields `addr:size:rkey:lid:dctn:gid_present:gid`; only the leading
/// address and size are interpreted here, the library consumes the rest.
#[derive(Debug, Clone)]
pub struct RdmaToken {
inner: cuobject::RdmaToken,
/// Start of the client buffer (a copy of the parsed field).
pub remote_addr: u64,
/// Length of the client buffer (a copy of the parsed field).
pub buffer_len: u64,
}
impl RdmaToken {
pub fn parse(raw: &str) -> Result<Self, CuObjectError> {
let inner = cuobject::RdmaToken::parse(raw)?;
Ok(Self {
remote_addr: inner.remote_addr(),
buffer_len: inner.buffer_len(),
inner,
})
}
pub fn as_str(&self) -> &str {
self.inner.as_str()
}
}
/// Tuning for one server instance.
#[derive(Debug, Clone)]
pub struct CuObjectConfig {
pub port: u16,
pub num_dcis: i32,
pub cq_depth: u32,
/// Size of one staging buffer; one RDMA write moves at most this much.
pub chunk_bytes: usize,
/// Total registered staging memory per server instance.
pub pool_bytes: usize,
/// Complete transfers through the library's asynchronous mode (submit,
/// then wait on the channel's completion descriptor) instead of one
/// blocking library call per transfer.
pub async_transfers: bool,
}
impl Default for CuObjectConfig {
fn default() -> Self {
Self {
port: DEFAULT_PORT,
num_dcis: 128,
cq_depth: 640,
chunk_bytes: 64 * 1024 * 1024,
pool_bytes: 1024 * 1024 * 1024,
async_transfers: true,
}
}
}
struct Staging {
buffer: RegisteredBuffer<Arc<Server>>,
free: parking_lot::Mutex<VecDeque<usize>>,
permits: Semaphore,
chunk_bytes: usize,
}
/// One cuObject server bound to the RDMA device that owns an IP address.
pub struct CuObjectServer {
server: Arc<Server>,
staging: Staging,
addr: IpAddr,
port: u16,
/// One permit per library channel (DC initiator): a transfer waits here
/// instead of failing with `EBUSY` when every channel is in use.
channels: Arc<Semaphore>,
async_transfers: bool,
}
impl std::fmt::Debug for CuObjectServer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CuObjectServer")
.field("addr", &self.addr)
.field("port", &self.port)
.field("chunk_bytes", &self.staging.chunk_bytes)
.finish()
}
}
/// Several byte ranges of one [`RegisteredArena`], sent in order as one
/// RDMA operation (at most [`MAX_SG_RANGES`]).
pub struct ArenaRanges {
pub arena: Arc<RegisteredArena>,
/// `(local_offset, len)` pairs, in stream order.
pub ranges: Vec<(usize, usize)>,
}
impl ArenaRanges {
pub fn total_len(&self) -> usize {
self.ranges.iter().map(|(_, len)| *len).sum()
}
}
/// A byte range of a [`RegisteredArena`] to send from.
pub struct ArenaRange {
pub arena: Arc<RegisteredArena>,
pub local_offset: usize,
pub len: usize,
}
/// Host memory registered with one server, owned by the caller (see
/// [`CuObjectServer::register_arena`]).
pub struct RegisteredArena {
buffer: RegisteredBuffer<Arc<Server>>,
server: Arc<CuObjectServer>,
id: u64,
}
impl RegisteredArena {
/// Length of the registered memory.
pub fn len(&self) -> usize {
self.buffer.len()
}
pub fn is_empty(&self) -> bool {
self.buffer.is_empty()
}
/// Process-unique id of this registration.
pub fn id(&self) -> u64 {
self.id
}
/// The server this memory is registered with.
pub fn server(&self) -> &Arc<CuObjectServer> {
&self.server
}
/// Raw pointer to the start of the registered memory. The memory lives as
/// long as this arena; callers hand out disjoint ranges of it and never
/// touch a range while a transfer sends it.
pub fn as_mut_ptr(&self) -> *mut u8 {
self.buffer.as_mut_ptr()
}
}
impl std::fmt::Debug for RegisteredArena {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RegisteredArena")
.field("id", &self.id)
.field("len", &self.len())
.finish()
}
}
/// A reserved staging chunk; returned to the pool on drop.
///
/// The chunk's index is unique while it is reserved, so its range of the
/// staging buffer has one owner. Transfers take the chunk by value, so no
/// Rust borrow of the range overlaps an RDMA operation on it.
pub struct StagingChunk {
server: Arc<CuObjectServer>,
index: usize,
len: usize,
}
impl StagingChunk {
pub fn capacity(&self) -> usize {
self.server.staging.chunk_bytes
}
/// Bytes currently staged.
pub fn len(&self) -> usize {
self.len
}
pub fn is_empty(&self) -> bool {
self.len == 0
}
/// Copies `data` at `self.len()` and advances the staged length.
pub fn append(&mut self, data: &[u8]) -> Result<(), CuObjectError> {
if self.len + data.len() > self.capacity() {
return Err(CuObjectError::Invalid("staging append exceeds chunk"));
}
self.spare_mut()?[..data.len()].copy_from_slice(data);
self.len += data.len();
Ok(())
}
pub fn clear(&mut self) {
self.len = 0;
}
pub fn is_full(&self) -> bool {
self.len >= self.capacity()
}
/// The bytes staged so far.
#[allow(unsafe_code)]
pub fn staged(&self) -> Result<&[u8], CuObjectError> {
// SAFETY: the range lies in this chunk (see the type docs); `&self`
// excludes `spare_mut`, and transfers own the chunk they move.
Ok(unsafe { self.server.staging.buffer.slice(self.start(), self.len)? })
}
/// The unfilled remainder of the chunk, for a reader to fill directly.
#[allow(unsafe_code)]
pub fn spare_mut(&mut self) -> Result<&mut [u8], CuObjectError> {
let len = self.capacity() - self.len;
// SAFETY: the range lies in this chunk (see the type docs) and
// `&mut self` excludes every other borrow of it.
Ok(unsafe { self.server.staging.buffer.slice_mut(self.start() + self.len, len)? })
}
/// Marks `n` more bytes of the spare area as staged.
pub fn advance(&mut self, n: usize) -> Result<(), CuObjectError> {
if self.len + n > self.capacity() {
return Err(CuObjectError::Invalid("staging advance exceeds chunk"));
}
self.len += n;
Ok(())
}
fn start(&self) -> usize {
self.index * self.capacity()
}
}
impl Drop for StagingChunk {
fn drop(&mut self) {
self.server.staging.free.lock().push_back(self.index);
self.server.staging.permits.add_permits(1);
}
}
/// The local side of one GET, owned by the transfer until the DMA finished.
enum Local {
/// A range of the staging buffer, inside a chunk the transfer also owns.
Staging { offset: usize, len: usize },
/// A range of a caller-owned arena.
Arena {
arena: Arc<RegisteredArena>,
offset: usize,
len: usize,
},
/// Several ranges of a caller-owned arena, sent as one operation.
ArenaList {
arena: Arc<RegisteredArena>,
entries: Vec<SgEntry>,
},
}
impl Local {
fn len(&self) -> usize {
match self {
Self::Staging { len, .. } | Self::Arena { len, .. } => *len,
Self::ArenaList { entries, .. } => entries.iter().map(|entry| entry.size).sum(),
}
}
}
/// Why an asynchronous GET did not complete.
enum AsyncFailure {
/// The library has no completion descriptor; nothing was submitted.
Unavailable,
/// The GET failed, or was never submitted; nothing is in flight.
Failed(CuObjectError),
/// Waiting failed after submission: the NIC may still read the memory.
InFlight(CuObjectError),
}
impl From<cuobject::Error> for AsyncFailure {
fn from(error: cuobject::Error) -> Self {
Self::Failed(error.into())
}
}
/// The handle of the one GET in flight on an asynchronous channel.
const ASYNC_HANDLE: NonZeroUsize = NonZeroUsize::MIN;
impl CuObjectServer {
/// Creates the server and its registered staging pool.
pub fn new(addr: IpAddr, config: &CuObjectConfig) -> Result<Arc<Self>, CuObjectError> {
if config.chunk_bytes == 0 || config.chunk_bytes > MAX_RDMA_OP_BYTES || config.pool_bytes < config.chunk_bytes {
return Err(CuObjectError::Invalid("invalid staging configuration"));
}
let mut options = ServerOptions::default();
// A non-positive count keeps the library default.
options.num_dcis = u32::try_from(config.num_dcis).unwrap_or(0);
options.cq_depth = config.cq_depth;
let server = Arc::new(Server::new(addr, config.port, &options)?);
let chunks = config.pool_bytes / config.chunk_bytes;
let buffer = RegisteredBuffer::new(Arc::clone(&server), chunks * config.chunk_bytes)?;
Ok(Arc::new(Self {
channels: Arc::new(Semaphore::new(usize::try_from(config.num_dcis).unwrap_or(1).max(1))),
async_transfers: config.async_transfers,
server,
staging: Staging {
buffer,
free: parking_lot::Mutex::new((0..chunks).collect()),
permits: Semaphore::new(chunks),
chunk_bytes: config.chunk_bytes,
},
addr,
port: config.port,
}))
}
pub fn addr(&self) -> IpAddr {
self.addr
}
pub fn port(&self) -> u16 {
self.port
}
pub fn chunk_bytes(&self) -> usize {
self.staging.chunk_bytes
}
/// Reserves one staging chunk, waiting up to `timeout` for a free one.
pub async fn reserve(self: &Arc<Self>, timeout: Duration) -> Result<StagingChunk, CuObjectError> {
let permit = tokio::time::timeout(timeout, self.staging.permits.acquire())
.await
.map_err(|_| CuObjectError::PoolExhausted)?
.map_err(|_| CuObjectError::PoolExhausted)?;
permit.forget();
let index = self.staging.free.lock().pop_front().ok_or(CuObjectError::PoolExhausted)?;
Ok(StagingChunk {
server: Arc::clone(self),
index,
len: 0,
})
}
/// Reserves one staging chunk without waiting; `None` when the pool is empty.
pub fn try_reserve(self: &Arc<Self>) -> Option<StagingChunk> {
let permit = self.staging.permits.try_acquire().ok()?;
permit.forget();
let index = self.staging.free.lock().pop_front()?;
Some(StagingChunk {
server: Arc::clone(self),
index,
len: 0,
})
}
/// Staging chunks currently free in the pool (a hint; another reservation may win).
pub fn available_chunks(&self) -> usize {
self.staging.permits.available_permits()
}
/// Registers `len` bytes of zero-filled, page-aligned host memory with this
/// server for callers that manage the memory themselves (a shard arena the
/// decoder reads into and the server RDMA-writes from without staging).
pub fn register_arena(self: &Arc<Self>, len: usize) -> Result<Arc<RegisteredArena>, CuObjectError> {
let buffer = RegisteredBuffer::new(Arc::clone(&self.server), len)?;
static NEXT_ID: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
Ok(Arc::new(RegisteredArena {
buffer,
server: Arc::clone(self),
id: NEXT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
}))
}
/// RDMA-writes the staged bytes of `chunk` to `token.remote_addr +
/// remote_offset`. The transfer owns the chunk until the DMA finished, so
/// cancelling the awaiting future can never release the staging slot under
/// an in-flight write. Returns the chunk with the byte count for reuse.
pub async fn write_to_client_owned(
self: &Arc<Self>,
key: &str,
token: &RdmaToken,
remote_offset: u64,
chunk: StagingChunk,
) -> Result<(u64, StagingChunk), CuObjectError> {
if chunk.is_empty() {
return Ok((0, chunk));
}
let local = Local::Staging {
offset: chunk.start(),
len: chunk.len(),
};
self.get_owned(key, token, remote_offset, local, chunk).await
}
/// RDMA-writes `source.len` bytes at `source.local_offset` of
/// `source.arena` to `token.remote_addr + remote_offset`, keeping `keep`
/// alive until the DMA finished (the caller passes whatever owns the arena
/// bytes). The arena must have been registered with this server.
pub async fn write_to_client_from_arena_owned<T: Send + 'static>(
self: &Arc<Self>,
key: &str,
token: &RdmaToken,
remote_offset: u64,
source: ArenaRange,
keep: T,
) -> Result<(u64, T), CuObjectError> {
if source.len == 0 {
return Ok((0, keep));
}
let local = Local::Arena {
arena: source.arena,
offset: source.local_offset,
len: source.len,
};
self.get_owned(key, token, remote_offset, local, keep).await
}
/// RDMA-writes all of `source.ranges` (in order, as one operation) to
/// `token.remote_addr + remote_offset`, keeping `keep` alive until the DMA
/// finished. The arena must have been registered with this server.
pub async fn write_to_client_sg_owned<T: Send + 'static>(
self: &Arc<Self>,
key: &str,
token: &RdmaToken,
remote_offset: u64,
source: ArenaRanges,
keep: T,
) -> Result<(u64, T), CuObjectError> {
if source.ranges.len() > MAX_SG_RANGES {
return Err(CuObjectError::Invalid("too many scatter-gather ranges"));
}
if source.total_len() == 0 {
return Ok((0, keep));
}
let entries = source
.ranges
.iter()
.map(|&(offset, size)| SgEntry {
offset: offset as u64,
size,
})
.collect();
let local = Local::ArenaList {
arena: source.arena,
entries,
};
self.get_owned(key, token, remote_offset, local, keep).await
}
/// RDMA-reads `len` bytes from `token.remote_addr + remote_offset` into the
/// (empty) `chunk`, owning it for the whole DMA like
/// [`Self::write_to_client_owned`]. On success the chunk holds `len` staged
/// bytes.
pub async fn read_from_client_owned(
self: &Arc<Self>,
key: &str,
token: &RdmaToken,
remote_offset: u64,
len: usize,
mut chunk: StagingChunk,
) -> Result<StagingChunk, CuObjectError> {
chunk.clear();
if len == 0 {
return Ok(chunk);
}
if len > chunk.capacity() {
return Err(CuObjectError::Invalid("read exceeds the staging chunk"));
}
let server = Arc::clone(self);
let key = key.to_owned();
let token = token.inner.clone();
let channel_permit = self.channel_permit().await?;
tokio::task::spawn_blocking(move || {
let _channel_permit = channel_permit;
let mut channel = Channel::lease(Arc::clone(&server.server))?;
let moved = channel.put(&key, &token, remote_offset, &server.staging.buffer, chunk.start(), len)?;
check_moved(moved as u64, len as u64)?;
chunk.advance(len)?;
Ok(chunk)
})
.await
.map_err(|error| join_error("read task", error))?
}
async fn channel_permit(&self) -> Result<tokio::sync::OwnedSemaphorePermit, CuObjectError> {
Arc::clone(&self.channels)
.acquire_owned()
.await
.map_err(|_| CuObjectError::Invalid("server closed"))
}
/// RDMA-writes `local` to the client and hands `keep` back once the DMA
/// finished. The transfer runs in a task of its own that owns `local`,
/// `keep` and the channel, so dropping this future never releases memory
/// the NIC may still read.
async fn get_owned<T: Send + 'static>(
self: &Arc<Self>,
key: &str,
token: &RdmaToken,
remote_offset: u64,
local: Local,
keep: T,
) -> Result<(u64, T), CuObjectError> {
let expected = local.len() as u64;
let server = Arc::clone(self);
let key = key.to_owned();
let token = token.inner.clone();
let channel_permit = self.channel_permit().await?;
tokio::spawn(async move {
if server.async_transfers {
match server.get_async(&key, &token, remote_offset, &local).await {
Ok(()) => {
drop(channel_permit);
return Ok((expected, keep));
}
Err(AsyncFailure::Unavailable) => {}
Err(AsyncFailure::Failed(error)) => return Err(error),
Err(AsyncFailure::InFlight(error)) => {
// The NIC may still read this memory: never release it.
std::mem::forget(local);
std::mem::forget(keep);
return Err(error);
}
}
}
tokio::task::spawn_blocking(move || {
let _channel_permit = channel_permit;
let mut channel = Channel::lease(Arc::clone(&server.server))?;
let mut list = None;
let source = server.source(&local, &mut list)?;
let moved = channel.get(&key, &token, remote_offset, source)?;
check_moved(moved as u64, expected)?;
// `keep` (the chunk or the arena owner) is released only here.
Ok((expected, keep))
})
.await
.map_err(|error| join_error("write task", error))?
})
.await
.map_err(|error| join_error("write task", error))?
}
/// Moves `local` with the library's asynchronous mode: the GET is
/// submitted on a channel of its own and the task waits on that channel's
/// completion descriptor instead of holding a blocking thread.
// SAFETY: the allowance covers only this function; its two unsafe calls
// each state the invariant they rely on.
#[allow(unsafe_code)]
async fn get_async(
&self,
key: &str,
token: &cuobject::RdmaToken,
remote_offset: u64,
local: &Local,
) -> Result<(), AsyncFailure> {
let mut channel = Channel::lease(Arc::clone(&self.server))?;
let fd = match channel.completion_fd() {
Ok(fd) => fd,
Err(cuobject::Error::AsyncUnavailable(_)) => return Err(AsyncFailure::Unavailable),
Err(error) => return Err(error.into()),
};
// SAFETY: the library owns the descriptor and keeps it open while the
// server lives; `fd` holds the server, and nothing here closes or
// replaces the descriptor while it is registered.
let completions = unsafe { AsyncFd::register_with_interest(fd, Interest::READABLE) }.map_err(|error| {
AsyncFailure::Failed(CuObjectError::Os {
op: "completion fd",
source: error.into_parts().1,
})
})?;
let mut list = None;
let source = self.source(local, &mut list).map_err(AsyncFailure::Failed)?;
// SAFETY: the memory behind `source` belongs to `local`, owned by the
// calling task together with the transfer's `keep`; staging chunks and
// arena ranges given to a transfer are not borrowed by anyone else.
// This function returns only after the completion carrying the handle
// was drained, except through `InFlight`, where the channel and the
// list are leaked here and the caller leaks `local` and `keep`.
unsafe { channel.get_async(key, token, remote_offset, source, ASYNC_HANDLE) }?;
let mut events = [Completion::default(); 8];
loop {
let mut ready = match completions.readable().await {
Ok(ready) => ready,
Err(source) => {
std::mem::forget(list);
std::mem::forget(channel);
return Err(AsyncFailure::InFlight(CuObjectError::Os {
op: "completion wait",
source,
}));
}
};
loop {
let landed = match channel.process_completions(&mut events) {
Ok(landed) => landed,
Err(error) => {
std::mem::forget(list);
std::mem::forget(channel);
return Err(AsyncFailure::InFlight(error.into()));
}
};
if let Some(done) = events[..landed].iter().find(|event| event.handle() == ASYNC_HANDLE.get()) {
// A completion carries no byte count: success moved the whole range.
return done
.result()
.map_err(|source| AsyncFailure::Failed(CuObjectError::Transfer { verbs_status: 0, source }));
}
if landed < events.len() {
break;
}
}
ready.clear_ready();
}
}
/// The library view of `local`; a scatter-gather list is built into `list`.
fn source<'a: 'l, 'l>(
&'a self,
local: &'a Local,
list: &'l mut Option<SgBuffer<'a, Arc<Server>>>,
) -> Result<Source<'l, Arc<Server>>, CuObjectError> {
Ok(match local {
Local::Staging { offset, len } => Source::Range {
buffer: &self.staging.buffer,
offset: *offset,
len: *len,
},
Local::Arena { arena, offset, len } => Source::Range {
buffer: &arena.buffer,
offset: *offset,
len: *len,
},
Local::ArenaList { arena, entries } => Source::List(list.insert(arena.buffer.sg_buffer(entries)?)),
})
}
}
fn check_moved(moved: u64, expected: u64) -> Result<u64, CuObjectError> {
if moved != expected {
return Err(CuObjectError::ShortTransfer { moved, expected });
}
Ok(moved)
}
fn join_error(op: &'static str, error: tokio::task::JoinError) -> CuObjectError {
CuObjectError::Os {
op,
source: std::io::Error::other(error),
}
}
/// Copies owned bytes into staging; convenience for callers holding `Bytes`.
pub fn fill_chunk(chunk: &mut StagingChunk, data: &Bytes) -> Result<(), CuObjectError> {
chunk.append(data)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn token_parses_leading_fields_and_rejects_garbage() {
let token =
RdmaToken::parse("0000f52eddc00000:00100000:001824d2:0000:002873:1:00000000000000000000ffff0a0d5410").expect("token");
assert_eq!(token.remote_addr, 0x0000_f52e_ddc0_0000);
assert_eq!(token.buffer_len, 0x0010_0000);
assert!(matches!(RdmaToken::parse("nothex:00100000:1:2:3:4:5"), Err(CuObjectError::Token(_))));
assert!(RdmaToken::parse("0000f52eddc00000:00000000:1:2:3:4:5").is_err());
assert!(RdmaToken::parse("0000f52eddc00000:00100000").is_err());
}
}
+3
View File
@@ -39,5 +39,8 @@ serde = { workspace = true, features = ["derive"] }
rmp-serde = { workspace = true }
rustfs-filemeta = { workspace = true }
[dev-dependencies]
serde_json.workspace = true
[lib]
doctest = false
+31 -3
View File
@@ -474,6 +474,12 @@ pub struct BucketTargetUsageInfo {
#[derive(Debug, Default, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct BucketUsageInfo {
pub size: u64,
/// Provenance of this value. Missing and unknown states remain unproven.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub usage_value_state: Option<crate::BucketUsageValueState>,
/// Certification of this exact value, independent of aggregation time.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub usage_certification: Option<crate::BucketUsageCertification>,
/// Bucket identity certified by every set contributing to this snapshot.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub bucket_incarnation: Option<String>,
@@ -580,6 +586,18 @@ pub struct DataUsageInfo {
/// which last-known-good generation contributed to the view.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub usage_snapshot_set_states: Vec<DataUsageSnapshotSetState>,
/// Complete mixed observations for admin display only. Legacy bucket maps
/// and quota consumers continue to use the canonical values above.
#[serde(
default,
skip_serializing_if = "HashMap::is_empty",
deserialize_with = "crate::usage_observation::deserialize_bucket_observations"
)]
pub usage_snapshot_bucket_observations: HashMap<String, crate::DataUsageBucketObservation>,
/// Response-only marker: a projected admin view must never be persisted or
/// admitted as a quota/cache baseline, including after serialization.
#[serde(default, skip_serializing_if = "std::ops::Not::not")]
pub usage_snapshot_admin_projection: bool,
/// Buckets whose dirty-usage generation moved while this complete
/// snapshot was being walked. Their `buckets_usage` values are the walk
/// result, which the cycle could not certify as current; the next cycle
@@ -709,7 +727,8 @@ pub fn observed_data_usage_is_newer(observed: &DataUsageInfo, authoritative: &Da
/// This applies the structural, exact-baseline, and generation checks of
/// [`observed_data_usage_is_newer`] without retaining the baseline's bucket maps.
pub fn observed_data_usage_is_newer_than_identity(observed: &DataUsageInfo, authoritative: DataUsageSnapshotIdentity) -> bool {
observed.usage_snapshot_converged == Some(false)
!observed.usage_snapshot_admin_projection
&& observed.usage_snapshot_converged == Some(false)
&& (observed.is_complete_bucket_usage_snapshot() || observed.is_valid_partial_snapshot())
&& observed.usage_snapshot_authoritative_baseline == Some(authoritative)
&& data_usage_identity_is_newer(observed.snapshot_identity(), authoritative)
@@ -2024,7 +2043,8 @@ impl DataUsageInfo {
/// Whether this snapshot authoritatively covers every reported bucket.
pub fn is_complete_bucket_usage_snapshot(&self) -> bool {
!self.usage_snapshot_bootstrap_pending
!self.usage_snapshot_admin_projection
&& !self.usage_snapshot_bootstrap_pending
&& self.usage_snapshot_complete
&& self.last_update.is_some()
&& u64::try_from(self.buckets_usage.len()).ok() == Some(self.buckets_count)
@@ -2034,7 +2054,8 @@ impl DataUsageInfo {
/// admin display. Partial data is accepted only with unique set states,
/// a plan digest for every state, and at least one usable generation.
pub fn is_valid_partial_snapshot(&self) -> bool {
if self.usage_snapshot_bootstrap_pending
if self.usage_snapshot_admin_projection
|| self.usage_snapshot_bootstrap_pending
|| !self.usage_snapshot_partial
|| self.usage_snapshot_converged != Some(false)
|| self.last_update.is_none()
@@ -2072,9 +2093,11 @@ impl DataUsageInfo {
Ok(name) => name,
Err(_) => return,
};
self.usage_snapshot_bucket_observations.remove(&bucket_name);
// Update bucket statistics
if let Some(bucket_usage) = self.buckets_usage.get_mut(&bucket_name) {
bucket_usage.mark_observed();
bucket_usage.size += meta_object.size as u64;
bucket_usage.objects_count += 1;
bucket_usage.versions_count += 1; // Simplified: assume 1 version per object
@@ -2127,6 +2150,7 @@ impl DataUsageInfo {
Ok(name) => name,
Err(_) => return,
};
self.usage_snapshot_bucket_observations.remove(&bucket_name);
// Calculate accurate statistics from all versions
let mut total_size = 0u64;
@@ -2155,6 +2179,7 @@ impl DataUsageInfo {
// Update bucket statistics
if let Some(bucket_usage) = self.buckets_usage.get_mut(&bucket_name) {
bucket_usage.mark_observed();
bucket_usage.size += total_size;
bucket_usage.objects_count += 1;
bucket_usage.versions_count += versions_count;
@@ -2335,6 +2360,9 @@ impl BucketUsageInfo {
/// Add size summary to this bucket usage
/// Merge another BucketUsageInfo into this one
pub fn merge(&mut self, other: &BucketUsageInfo) {
// Adding contributions produces a new value, not either input's
// whole-bucket certificate. The scanner may certify the final sum.
self.mark_observed();
if self.bucket_incarnation != other.bucket_incarnation {
self.bucket_incarnation = None;
}
+2
View File
@@ -13,5 +13,7 @@
// limitations under the License.
pub mod data_usage;
pub mod usage_observation;
pub use data_usage::*;
pub use usage_observation::*;
+265
View File
@@ -0,0 +1,265 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
//! Diagnostic provenance and response-only projections of complete bucket observations.
use crate::{BucketUsageInfo, DataUsageInfo, DataUsageSnapshotIdentity};
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, time::SystemTime};
pub const DATA_USAGE_BUCKET_OBSERVATION_VERSION: u16 = 1;
/// Provenance of the returned bucket value, independent of quota authority.
#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum BucketUsageValueState {
Certified,
Carried,
Observed,
#[serde(other)]
Unknown,
}
/// A certification of this exact bucket value, never its publication timestamp.
#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
pub struct BucketUsageCertification {
pub epoch: u64,
pub cycle: u64,
pub certified_at: SystemTime,
}
/// Immutable provenance of one complete traversal contribution.
///
/// The scanner validates its storage-owned sweep identity before constructing
/// this public projection. Equal start/request plans are allowed when a fresh
/// set contributes alongside another set's mixed traversal.
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
pub struct DataUsageBucketObservationSource {
pub pool_index: u64,
pub set_index: u64,
pub bucket_incarnation: String,
pub scanner_epoch: u64,
pub scanner_cycle: u64,
pub scan_plan_digest: [u8; 32],
pub started_plan: [u8; 32],
pub requested_plan: [u8; 32],
pub completed_at: SystemTime,
}
/// An additive companion; legacy bucket maps never contain this mixed value.
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
pub struct DataUsageBucketObservation {
pub version: u16,
pub usage: BucketUsageInfo,
/// Exact enclosing candidate identity. Rewrapping preserves source times.
pub snapshot_identity: DataUsageSnapshotIdentity,
/// Oldest contribution time, so a newer set cannot hide an older value.
pub completed_at: SystemTime,
/// Strictly ordered, complete coverage of the enclosing live set inventory.
pub sources: Vec<DataUsageBucketObservationSource>,
}
/// Companion evolution must not make an otherwise usable canonical snapshot
/// unreadable. Unsupported or malformed diagnostic entries never grant proof.
pub(crate) fn deserialize_bucket_observations<'de, D>(
deserializer: D,
) -> Result<HashMap<String, DataUsageBucketObservation>, D::Error>
where
D: serde::Deserializer<'de>,
{
#[derive(Deserialize)]
#[serde(untagged)]
enum Entry {
Observation(Box<DataUsageBucketObservation>),
Ignored(serde::de::IgnoredAny),
}
Ok(HashMap::<String, Entry>::deserialize(deserializer)?
.into_iter()
.filter_map(|(bucket, entry)| match entry {
Entry::Observation(observation) if observation.version == DATA_USAGE_BUCKET_OBSERVATION_VERSION => {
Some((bucket, *observation))
}
Entry::Observation(_) | Entry::Ignored(_) => None,
})
.collect())
}
impl BucketUsageInfo {
/// Attach a certificate only after the caller proves complete bucket coverage.
pub fn certify(&mut self, certification: BucketUsageCertification) {
self.usage_value_state = Some(BucketUsageValueState::Certified);
self.usage_certification = Some(certification);
}
/// Preserve the certificate when carrying the exact prior bucket value.
pub fn mark_carried(&mut self) {
self.normalize_usage_provenance();
self.usage_value_state = Some(BucketUsageValueState::Carried);
}
/// The value changed without a complete bucket certificate.
pub fn mark_observed(&mut self) {
self.usage_value_state = Some(BucketUsageValueState::Observed);
self.usage_certification = None;
}
/// Future or legacy provenance cannot authorize a retained certificate.
pub fn normalize_usage_provenance(&mut self) {
if !matches!(
self.usage_value_state,
Some(BucketUsageValueState::Certified | BucketUsageValueState::Carried)
) {
self.usage_certification = None;
}
if self.usage_value_state == Some(BucketUsageValueState::Certified) && self.usage_certification.is_none() {
self.usage_value_state = Some(BucketUsageValueState::Unknown);
}
}
}
impl DataUsageBucketObservation {
/// Verify the public provenance against the enclosing candidate and current
/// storage-owned incarnation. This never grants publication or ACK authority.
pub fn matches_snapshot(&self, snapshot: &DataUsageInfo, incarnation: &str) -> bool {
let Some(root_generation) = snapshot.scanner_epoch.zip(snapshot.scanner_cycle) else {
return false;
};
if self.version != DATA_USAGE_BUCKET_OBSERVATION_VERSION
|| snapshot.usage_snapshot_admin_projection
|| self.snapshot_identity != snapshot.snapshot_identity()
|| incarnation.is_empty()
|| self.usage.bucket_incarnation.as_deref() != Some(incarnation)
|| self.sources.is_empty()
|| self.usage.usage_certification.is_some()
|| self.usage.usage_value_state != Some(BucketUsageValueState::Observed)
|| self.sources.iter().map(|source| source.completed_at).min() != Some(self.completed_at)
{
return false;
}
let mut previous = None;
let mut plan = None;
for state in &snapshot.usage_snapshot_set_states {
let key = (state.pool_index, state.set_index);
if previous.is_some_and(|previous| previous >= key)
|| state.scan_plan_digest.is_none()
|| plan.is_some_and(|plan| Some(plan) != state.scan_plan_digest)
{
return false;
}
previous = Some(key);
plan = state.scan_plan_digest;
}
let mut sources = self.sources.iter();
for state in snapshot.usage_snapshot_set_states.iter().filter(|state| !state.tombstone) {
let Some(source) = sources.next() else {
return false;
};
let Some(set_generation) = state.scanner_epoch.zip(state.scanner_cycle) else {
return false;
};
if (source.pool_index, source.set_index) != (state.pool_index, state.set_index)
|| source.bucket_incarnation != incarnation
|| Some(source.scan_plan_digest) != state.scan_plan_digest
|| (source.scanner_epoch, source.scanner_cycle) > set_generation
|| set_generation > root_generation
{
return false;
}
}
sources.next().is_none()
}
}
impl DataUsageInfo {
/// Overlay validated companions on an owned admin response only.
///
/// `incarnations` must come from current storage metadata, not the companion.
/// The projection is marked explicitly so persistence and quota boundaries
/// can reject accidental reuse. Invalid companions leave canonical values
/// unchanged. Counter overflow rejects the whole projection.
pub fn project_bucket_observations_for_admin(&mut self, incarnations: &HashMap<String, String>) -> usize {
if self.usage_snapshot_admin_projection
|| (!self.is_complete_bucket_usage_snapshot() && !self.is_valid_partial_snapshot())
{
return 0;
}
let observations =
self.usage_snapshot_bucket_observations
.iter()
.filter(|(bucket, observation)| {
if self.usage_snapshot_complete
&& (!self.usage_snapshot_pending_buckets.iter().any(|pending| pending == *bucket)
|| u64::try_from(self.usage_snapshot_pending_buckets.len()).ok()
!= Some(self.usage_snapshot_pending_bucket_count))
{
return false;
}
if self
.buckets_usage
.get(*bucket)
.and_then(|usage| usage.usage_certification)
.is_some_and(|certificate| {
observation.sources.iter().all(|source| {
(source.scanner_epoch, source.scanner_cycle) <= (certificate.epoch, certificate.cycle)
})
})
{
return false;
}
incarnations.get(*bucket).is_some_and(|incarnation| {
self.buckets_usage
.get(*bucket)
.and_then(|usage| usage.bucket_incarnation.as_ref())
.is_none_or(|canonical| canonical == incarnation)
&& observation.matches_snapshot(self, incarnation)
})
})
.collect::<HashMap<_, _>>();
if observations.is_empty() {
return 0;
}
let mut values = self
.buckets_usage
.iter()
.filter(|(bucket, _)| !observations.contains_key(bucket))
.map(|(_, usage)| usage)
.chain(observations.values().map(|observation| &observation.usage));
let totals = values.try_fold([0_u64; 4], |total, usage| {
Some([
total[0].checked_add(usage.size)?,
total[1].checked_add(usage.objects_count)?,
total[2].checked_add(usage.versions_count)?,
total[3].checked_add(usage.delete_markers_count)?,
])
});
let Some([size, objects, versions, markers]) = totals else {
return 0;
};
let projected = observations.len();
for (bucket, observation) in observations {
self.buckets_usage.insert(bucket.clone(), observation.usage.clone());
}
self.bucket_sizes = self
.buckets_usage
.iter()
.map(|(bucket, usage)| (bucket.clone(), usage.size))
.collect();
self.buckets_count = u64::try_from(self.buckets_usage.len()).unwrap_or(u64::MAX);
self.objects_total_size = size;
self.objects_total_count = objects;
self.versions_total_count = versions;
self.delete_markers_total_count = markers;
self.replication_info.clear();
self.tier_stats = None;
self.unknown_tier_stats = None;
self.usage_snapshot_complete = false;
self.usage_snapshot_partial = true;
self.usage_snapshot_converged = Some(false);
self.usage_snapshot_observational = true;
self.usage_snapshot_admin_projection = true;
projected
}
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,323 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
use crate::DataUsageSnapshotSetState;
use std::time::Duration;
const INCARNATION: &str = "11111111-1111-4111-8111-111111111111";
fn time(seconds: u64) -> SystemTime {
SystemTime::UNIX_EPOCH + Duration::from_secs(seconds)
}
fn usage(size: u64) -> BucketUsageInfo {
BucketUsageInfo {
size,
objects_count: size,
versions_count: size,
bucket_incarnation: Some(INCARNATION.to_string()),
..Default::default()
}
}
fn snapshot() -> DataUsageInfo {
let mut main = usage(10);
main.certify(BucketUsageCertification {
epoch: 2,
cycle: 3,
certified_at: time(30),
});
main.mark_carried();
let mut snapshot = DataUsageInfo {
last_update: Some(time(90)),
scanner_epoch: Some(2),
scanner_cycle: Some(9),
buckets_count: 1,
buckets_usage: HashMap::from([("bucket".to_string(), main)]),
bucket_sizes: HashMap::from([("bucket".to_string(), 10)]),
usage_snapshot_complete: true,
usage_snapshot_converged: Some(false),
usage_snapshot_pending_buckets: vec!["bucket".to_string()],
usage_snapshot_pending_bucket_count: 1,
usage_snapshot_set_states: (0..2)
.map(|set_index| DataUsageSnapshotSetState {
pool_index: 0,
set_index,
scanner_epoch: Some(2),
scanner_cycle: Some(9),
scan_plan_digest: Some([1; 32]),
complete: true,
..Default::default()
})
.collect(),
..Default::default()
};
snapshot.calculate_totals();
let mut observed = usage(25);
observed.mark_observed();
let observation = DataUsageBucketObservation {
version: DATA_USAGE_BUCKET_OBSERVATION_VERSION,
usage: observed,
snapshot_identity: snapshot.snapshot_identity(),
completed_at: time(40),
sources: (0..2)
.map(|set_index| DataUsageBucketObservationSource {
pool_index: 0,
set_index,
bucket_incarnation: INCARNATION.to_string(),
scanner_epoch: 2,
scanner_cycle: 4 + set_index,
scan_plan_digest: [1; 32],
started_plan: [2; 32],
requested_plan: [3; 32],
completed_at: time(40 + set_index),
})
.collect(),
};
snapshot
.usage_snapshot_bucket_observations
.insert("bucket".to_string(), observation);
snapshot
}
fn incarnations() -> HashMap<String, String> {
HashMap::from([("bucket".to_string(), INCARNATION.to_string())])
}
#[test]
fn provenance_is_additive_and_unknown_states_do_not_keep_certificates() {
let legacy = usage(10);
let bytes = serde_json::to_vec(&legacy).expect("encode a legacy bucket without provenance");
let text = std::str::from_utf8(&bytes).expect("JSON is UTF-8");
assert!(!text.contains("usage_value_state"));
assert!(!text.contains("usage_certification"));
let decoded: BucketUsageInfo = serde_json::from_slice(&bytes).expect("read legacy bucket");
assert_eq!(decoded.usage_value_state, None);
assert_eq!(decoded.usage_certification, None);
let mut wire = serde_json::to_value(legacy).expect("encode future bucket fixture");
wire["usage_value_state"] = serde_json::json!("future_state");
wire["usage_certification"] =
serde_json::json!({"epoch":2,"cycle":3,"certified_at":{"secs_since_epoch":30,"nanos_since_epoch":0}});
let mut future: BucketUsageInfo = serde_json::from_value(wire).expect("unknown diagnostic enum remains readable");
future.normalize_usage_provenance();
assert_eq!(future.usage_value_state, Some(BucketUsageValueState::Unknown));
assert_eq!(future.usage_certification, None);
}
#[test]
fn carrying_preserves_time_but_adding_a_source_invalidates_the_certificate() {
let mut bucket = snapshot().buckets_usage.remove("bucket").expect("canonical bucket");
bucket.mark_carried();
assert_eq!(bucket.usage_certification.map(|certification| certification.certified_at), Some(time(30)));
bucket.merge(&usage(1));
assert_eq!(bucket.size, 11);
assert_eq!(bucket.usage_value_state, Some(BucketUsageValueState::Observed));
assert_eq!(bucket.usage_certification, None);
}
#[test]
fn direct_object_accumulation_does_not_reuse_the_old_certificate() {
let mut simple = snapshot();
simple.add_object("bucket/object", &rustfs_filemeta::MetaObject::default());
assert_eq!(simple.buckets_usage["bucket"].usage_value_state, Some(BucketUsageValueState::Observed));
assert_eq!(simple.buckets_usage["bucket"].usage_certification, None);
assert!(simple.usage_snapshot_bucket_observations.is_empty());
let mut versioned = snapshot();
versioned.add_object_from_file_meta("bucket/object", &rustfs_filemeta::FileMeta::default());
assert_eq!(versioned.buckets_usage["bucket"].usage_value_state, Some(BucketUsageValueState::Observed));
assert_eq!(versioned.buckets_usage["bucket"].usage_certification, None);
assert!(versioned.usage_snapshot_bucket_observations.is_empty());
}
#[test]
fn future_or_malformed_companions_do_not_break_the_canonical_reader() {
let canonical = snapshot();
for entry in [
serde_json::json!({"version": 2, "future_payload": {"new": true}}),
serde_json::json!({"version": 1, "usage": "broken"}),
] {
let mut wire = serde_json::to_value(&canonical).expect("canonical JSON");
wire["usage_snapshot_bucket_observations"]["bucket"] = entry;
let decoded: DataUsageInfo = serde_json::from_value(wire).expect("diagnostics cannot break canonical data");
assert_eq!(decoded.buckets_usage, canonical.buckets_usage);
assert!(decoded.usage_snapshot_bucket_observations.is_empty());
assert!(decoded.is_complete_bucket_usage_snapshot());
}
}
#[test]
fn complete_companion_projects_only_the_admin_copy_and_keeps_measurement_times() {
let canonical = snapshot();
let canonical_bytes = serde_json::to_vec(&canonical).expect("encode canonical candidate");
let mut response = canonical.clone();
assert_eq!(response.project_bucket_observations_for_admin(&incarnations()), 1);
assert_eq!(response.buckets_usage["bucket"].size, 25);
assert_eq!(response.buckets_usage["bucket"].usage_value_state, Some(BucketUsageValueState::Observed));
assert_eq!(response.buckets_usage["bucket"].usage_certification, None);
assert_eq!(response.objects_total_size, 25);
assert_eq!(response.bucket_sizes["bucket"], 25);
assert_eq!(response.last_update, canonical.last_update);
assert_eq!(response.usage_snapshot_bucket_observations["bucket"].completed_at, time(40));
assert!(response.usage_snapshot_admin_projection);
assert!(response.usage_snapshot_partial);
assert!(response.usage_snapshot_observational);
assert_eq!(response.usage_snapshot_converged, Some(false));
assert!(!response.is_complete_bucket_usage_snapshot());
assert!(
!response.is_valid_partial_snapshot(),
"response-only values cannot be a storage candidate"
);
assert_eq!(serde_json::to_vec(&canonical).expect("reencode original"), canonical_bytes);
assert_eq!(canonical.buckets_usage["bucket"].size, 10);
assert_eq!(
canonical.buckets_usage["bucket"]
.usage_certification
.map(|certificate| certificate.certified_at),
Some(time(30))
);
assert_eq!(response.project_bucket_observations_for_admin(&incarnations()), 0);
}
#[test]
fn invalid_companions_preserve_the_canonical_bucket() {
for invalid in 0..11 {
let mut candidate = snapshot();
let observation = candidate
.usage_snapshot_bucket_observations
.get_mut("bucket")
.expect("companion");
match invalid {
0 => observation.version += 1,
1 => observation.snapshot_identity.scanner_cycle = Some(8),
2 => {
observation.sources.pop();
}
3 => observation.sources[1].set_index = 0,
4 => observation.sources[1].scanner_cycle = 10,
5 => observation.sources[1].scan_plan_digest = [9; 32],
6 => observation.sources[1].bucket_incarnation = "other".to_string(),
7 => observation.completed_at = time(41),
8 => observation.usage.certify(BucketUsageCertification {
epoch: 2,
cycle: 9,
certified_at: time(90),
}),
9 => candidate.usage_snapshot_set_states[1].scanner_cycle = None,
10 => {
candidate
.buckets_usage
.get_mut("bucket")
.expect("canonical")
.bucket_incarnation = Some("recreated".to_string())
}
_ => unreachable!("bounded fixture variants"),
}
let before = candidate.clone();
assert_eq!(
candidate.project_bucket_observations_for_admin(&incarnations()),
0,
"invalid case {invalid}"
);
assert_eq!(candidate, before, "invalid case {invalid} changed canonical data");
}
}
#[test]
fn a_fresh_set_can_contribute_without_refreshing_an_older_mixed_set() {
let mut candidate = snapshot();
let observation = candidate
.usage_snapshot_bucket_observations
.get_mut("bucket")
.expect("companion");
observation.sources[1].started_plan = observation.sources[1].requested_plan;
observation.sources[1].completed_at = time(90);
assert_eq!(candidate.project_bucket_observations_for_admin(&incarnations()), 1);
assert_eq!(candidate.usage_snapshot_bucket_observations["bucket"].completed_at, time(40));
}
#[test]
fn companion_only_partial_keeps_legacy_maps_empty_until_admin_projection() {
let mut candidate = snapshot();
candidate.buckets_usage.clear();
candidate.bucket_sizes.clear();
candidate.buckets_count = 0;
candidate.calculate_totals();
candidate.usage_snapshot_complete = false;
candidate.usage_snapshot_partial = true;
candidate.usage_snapshot_observational = true;
for state in &mut candidate.usage_snapshot_set_states {
state.complete = false;
}
assert!(candidate.is_valid_partial_snapshot());
let wire = serde_json::to_value(&candidate).expect("encode companion-only observation");
assert_eq!(wire["buckets_usage"], serde_json::json!({}));
assert_eq!(wire["bucket_sizes"], serde_json::json!({}));
assert_eq!(wire["objects_total_size"], 0);
assert_eq!(candidate.project_bucket_observations_for_admin(&incarnations()), 1);
assert_eq!(candidate.objects_total_size, 25);
assert!(candidate.usage_snapshot_partial);
assert!(!candidate.usage_snapshot_complete);
}
#[test]
fn projection_rejects_counter_overflow_without_partial_mutation() {
let mut candidate = snapshot();
candidate.buckets_usage.insert("cold".to_string(), usage(u64::MAX));
candidate.buckets_count = 2;
let before = candidate.clone();
assert_eq!(candidate.project_bucket_observations_for_admin(&incarnations()), 0);
assert_eq!(candidate, before);
}
#[test]
fn a_newer_canonical_certificate_and_missing_pending_prevent_old_overlay() {
for newer_certificate in [false, true] {
let mut candidate = snapshot();
if newer_certificate {
candidate
.buckets_usage
.get_mut("bucket")
.expect("canonical")
.certify(BucketUsageCertification {
epoch: 2,
cycle: 9,
certified_at: time(90),
});
} else {
candidate.usage_snapshot_pending_buckets.clear();
candidate.usage_snapshot_pending_bucket_count = 0;
}
assert_eq!(candidate.project_bucket_observations_for_admin(&incarnations()), 0);
assert_eq!(candidate.buckets_usage["bucket"].size, 10);
}
}
#[test]
fn provenance_and_companions_change_candidate_bytes_and_round_trip_as_maps() {
let canonical = snapshot();
let original = serde_json::to_vec(&canonical).expect("encode candidate");
let mut changed = canonical.clone();
changed
.buckets_usage
.get_mut("bucket")
.expect("bucket")
.usage_certification
.as_mut()
.expect("certificate")
.certified_at = time(31);
assert_ne!(serde_json::to_vec(&changed).expect("encode changed certificate"), original);
let mut changed = canonical.clone();
changed
.usage_snapshot_bucket_observations
.get_mut("bucket")
.expect("observation")
.sources[0]
.started_plan = [8; 32];
assert_ne!(serde_json::to_vec(&changed).expect("encode changed source"), original);
let named = rmp_serde::to_vec_named(&canonical).expect("encode named map");
let restored: DataUsageInfo = rmp_serde::from_slice(&named).expect("read named map with additive fields");
assert_eq!(restored, canonical);
}
+8 -8
View File
@@ -99,10 +99,8 @@ rustfs-filemeta.workspace = true
bytes = { workspace = true, features = ["serde"] }
aws-sdk-s3 = { workspace = true, default-features = false, features = ["sigv4a", "default-https-client", "rt-tokio"] }
aws-sdk-sts = { workspace = true, default-features = false, features = ["default-https-client", "rt-tokio"] }
aws-config = { workspace = true }
aws-smithy-http-client = { workspace = true, default-features = false, features = ["rustls-aws-lc"] }
aws-smithy-types.workspace = true
async-compression = { workspace = true, features = ["tokio", "bzip2", "lz4", "xz"] }
async-trait = { workspace = true }
flate2.workspace = true
http.workspace = true
@@ -129,24 +127,26 @@ rand = { workspace = true, features = ["serde"] }
chrono = { workspace = true, features = ["serde"] }
hex-simd = { workspace = true }
md-5 = { workspace = true }
opentelemetry-proto = { workspace = true }
prost.workspace = true
sha2 = { workspace = true }
rustfs-tokio-tar = { workspace = true }
s3s = { workspace = true, features = ["minio"] }
zstd.workspace = true
time = { workspace = true, features = ["parsing", "formatting", "macros", "serde"] }
suppaftp = { workspace = true, features = ["rustls-aws-lc-rs", "tokio-rustls-aws-lc-rs"] }
rcgen.workspace = true
local-ip-address.workspace = true
anyhow.workspace = true
rustls = { workspace = true, default-features = false, features = ["aws-lc-rs", "logging", "tls12", "prefer-post-quantum", "std"] }
russh = { workspace = true, features = ["serde"] }
russh-sftp = { workspace = true }
zip.workspace = true
clap = { workspace = true, features = ["derive", "env"] }
[dev-dependencies]
async-compression = { workspace = true, features = ["tokio", "bzip2", "lz4", "xz"] }
aws-config = { workspace = true }
opentelemetry-proto = { workspace = true }
russh = { workspace = true, features = ["serde"] }
russh-sftp = { workspace = true }
suppaftp = { workspace = true, features = ["rustls-aws-lc-rs", "tokio-rustls-aws-lc-rs"] }
rustfs-tokio-tar = { workspace = true }
zip.workspace = true
same-file.workspace = true
aws-smithy-http-client = { workspace = true, default-features = false, features = ["test-util"] }
rustfs-heal.workspace = true
@@ -14,7 +14,42 @@
//! Differential cases of the `bucket_access` batch (see `super`).
use super::super::Recorder;
use super::super::{Recorder, none};
use aws_sdk_s3::Client;
use aws_sdk_s3::types::{BucketVersioningStatus, VersioningConfiguration};
pub(super) async fn cases(_s: &mut Recorder, _c: &Client) {}
const BUCKET: &str = "a2-bucket-access";
pub(super) async fn cases(s: &mut Recorder, c: &Client) {
s.step("CreateBucket", "a2-setup", c.create_bucket().bucket(BUCKET).send(), none)
.await;
versioning(s, c).await;
}
async fn versioning(s: &mut Recorder, c: &Client) {
let status = |o: &aws_sdk_s3::operation::get_bucket_versioning::GetBucketVersioningOutput| {
vec![
("status", format!("{:?}", o.status())),
("mfa_delete", format!("{:?}", o.mfa_delete())),
]
};
s.step(
"GetBucketVersioning",
"unconfigured",
c.get_bucket_versioning().bucket(BUCKET).send(),
status,
)
.await;
let suspended = VersioningConfiguration::builder()
.status(BucketVersioningStatus::Suspended)
.build();
let put = c.put_bucket_versioning().bucket(BUCKET).versioning_configuration(suspended);
s.step("PutBucketVersioning", "a2-suspended", put.send(), none).await;
s.step(
"GetBucketVersioning",
"suspended",
c.get_bucket_versioning().bucket(BUCKET).send(),
status,
)
.await;
}
@@ -14,7 +14,59 @@
//! Differential cases of the `bucket_core` batch (see `super`).
use super::super::Recorder;
use super::super::{Recorder, none};
use aws_sdk_s3::Client;
use aws_sdk_s3::types::{BucketLocationConstraint, CreateBucketConfiguration};
pub(super) async fn cases(_s: &mut Recorder, _c: &Client) {}
/// Names RustFS creates although the AWS grammar reserves them, and one it refuses.
const RESERVED_NAMES: [(&str, &str); 5] = [
("reserved-sthree", "sthree-dual-stack"),
("reserved-s3alias", "dual-stack-s3alias"),
("reserved-ol-s3", "dual-stack--ol-s3"),
("reserved-x-s3", "dual-stack--x-s3"),
("reserved-xn", "xn--dual-stack"),
];
pub(super) async fn cases(s: &mut Recorder, c: &Client) {
let located = |bucket: &str, location: &str| {
let configuration = CreateBucketConfiguration::builder()
.location_constraint(BucketLocationConstraint::from(location))
.build();
c.create_bucket().bucket(bucket).create_bucket_configuration(configuration)
};
s.step(
"CreateBucket",
"foreign-location",
located("dual-stack-foreign", "ap-south-1").send(),
none,
)
.await;
s.step("CreateBucket", "eu-alias", located("dual-stack-eu", "EU").send(), none)
.await;
for (case, name) in RESERVED_NAMES {
s.step("CreateBucket", case, c.create_bucket().bucket(name).send(), none)
.await;
}
for (case, bucket, header) in FORCE_DELETES {
// Each case deletes a bucket of its own; the create is setup, not a recorded step.
let _ = c.create_bucket().bucket(bucket).send().await;
let delete = c
.delete_bucket()
.bucket(bucket)
.customize()
.mutate_request(move |request| {
request.headers_mut().insert(header.0, header.1);
})
.send();
s.step("DeleteBucket", case, delete, none).await;
}
}
/// Force-delete headers under both spellings, with values each parser reads differently.
const FORCE_DELETES: [(&str, &str, (&str, &str)); 5] = [
("force-rustfs-true", "dual-stack-force-a", ("x-rustfs-force-delete", "true")),
("force-rustfs-invalid", "dual-stack-force-b", ("x-rustfs-force-delete", "maybe")),
("force-minio-true", "dual-stack-force-c", ("x-minio-force-delete", "true")),
("force-minio-numeric", "dual-stack-force-d", ("x-minio-force-delete", "1")),
("force-minio-invalid", "dual-stack-force-e", ("x-minio-force-delete", "maybe")),
];
@@ -13,8 +13,124 @@
// limitations under the License.
//! Differential cases of the `bucket_replication_lifecycle` batch (see `super`).
//!
//! Replication has no case of its own: storing a replication configuration needs a remote target
//! registered through the admin API, which this script does not drive.
use super::super::Recorder;
use super::super::{Fields, RETAIN_UNTIL_SECS, Recorder, none};
use aws_sdk_s3::Client;
use aws_sdk_s3::primitives::DateTime;
use aws_sdk_s3::types::{
AbortIncompleteMultipartUpload, BucketLifecycleConfiguration, DefaultRetention, ExpirationStatus, LifecycleExpiration,
LifecycleRule, LifecycleRuleAndOperator, LifecycleRuleFilter, NoncurrentVersionExpiration, ObjectLockConfiguration,
ObjectLockEnabled, ObjectLockRetentionMode, ObjectLockRule, Tag,
};
pub(super) async fn cases(_s: &mut Recorder, _c: &Client) {}
/// A name RustFS creates and serves that the AWS bucket grammar reserves.
const RESERVED_BUCKET: &str = "sthree-dual-stack-a3";
const LOCK_BUCKET: &str = "dual-stack-a3-lock";
fn lifecycle_rules(
output: &aws_sdk_s3::operation::get_bucket_lifecycle_configuration::GetBucketLifecycleConfigurationOutput,
) -> Fields {
vec![("rules", format!("{:?}", output.rules()))]
}
fn object_lock(output: &aws_sdk_s3::operation::get_object_lock_configuration::GetObjectLockConfigurationOutput) -> Fields {
vec![("configuration", format!("{:?}", output.object_lock_configuration()))]
}
pub(super) async fn cases(s: &mut Recorder, c: &Client) {
s.step("CreateBucket", "a3-reserved-name", c.create_bucket().bucket(RESERVED_BUCKET).send(), none)
.await;
let get_lifecycle = || c.get_bucket_lifecycle_configuration().bucket(RESERVED_BUCKET);
s.step("GetBucketLifecycleConfiguration", "a3-reserved-absent", get_lifecycle().send(), none)
.await;
let rule = LifecycleRule::builder()
.id("members")
.status(ExpirationStatus::Enabled)
.filter(
LifecycleRuleFilter::builder()
.and(
LifecycleRuleAndOperator::builder()
.prefix("logs/")
.tags(Tag::builder().key("tier").value("cold").build().expect("tag"))
.object_size_greater_than(1)
.build(),
)
.build(),
)
.expiration(LifecycleExpiration::builder().expired_object_delete_marker(true).build())
.noncurrent_version_expiration(
NoncurrentVersionExpiration::builder()
.noncurrent_days(7)
.newer_noncurrent_versions(2)
.build(),
)
.abort_incomplete_multipart_upload(AbortIncompleteMultipartUpload::builder().days_after_initiation(3).build())
.build()
.expect("lifecycle rule");
// A stored date is answered through a different conversion on each edge of the migration.
let dated = LifecycleRule::builder()
.id("dated")
.status(ExpirationStatus::Disabled)
.filter(LifecycleRuleFilter::builder().prefix("archive/").build())
.expiration(
LifecycleExpiration::builder()
.date(DateTime::from_secs(RETAIN_UNTIL_SECS))
.build(),
)
.build()
.expect("dated lifecycle rule");
let lifecycle = BucketLifecycleConfiguration::builder()
.rules(rule)
.rules(dated)
.build()
.expect("lifecycle configuration");
let put = c
.put_bucket_lifecycle_configuration()
.bucket(RESERVED_BUCKET)
.lifecycle_configuration(lifecycle);
s.step("PutBucketLifecycleConfiguration", "a3-every-member", put.send(), none)
.await;
s.step(
"GetBucketLifecycleConfiguration",
"a3-every-member",
get_lifecycle().send(),
lifecycle_rules,
)
.await;
let get_lock = |bucket: &str| c.get_object_lock_configuration().bucket(bucket);
s.step("GetObjectLockConfiguration", "a3-reserved-absent", get_lock(RESERVED_BUCKET).send(), none)
.await;
let create = c.create_bucket().bucket(LOCK_BUCKET).object_lock_enabled_for_bucket(true);
s.step("CreateBucket", "a3-lock", create.send(), none).await;
s.step(
"GetObjectLockConfiguration",
"a3-enabled-without-rule",
get_lock(LOCK_BUCKET).send(),
object_lock,
)
.await;
let lock = ObjectLockConfiguration::builder()
.object_lock_enabled(ObjectLockEnabled::Enabled)
.rule(
ObjectLockRule::builder()
.default_retention(
DefaultRetention::builder()
.mode(ObjectLockRetentionMode::Compliance)
.years(1)
.build(),
)
.build(),
)
.build();
let put = c
.put_object_lock_configuration()
.bucket(LOCK_BUCKET)
.object_lock_configuration(lock);
s.step("PutObjectLockConfiguration", "a3-years", put.send(), none).await;
s.step("GetObjectLockConfiguration", "a3-years", get_lock(LOCK_BUCKET).send(), object_lock)
.await;
}
@@ -12,9 +12,99 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//! Differential cases of the `listing_multipart` batch (see `super`).
//! Differential cases of the `listing_multipart` batch (see `super`): stored keys that need
//! encoding, with and without `encoding-type=url`, ListObjects' marker, ListObjectsV2 pagination,
//! and the listings' parameter refusals.
use super::super::Recorder;
use super::super::{Fields, Recorder, none};
use aws_sdk_s3::Client;
use aws_sdk_s3::primitives::ByteStream;
use aws_sdk_s3::types::EncodingType;
pub(super) async fn cases(_s: &mut Recorder, _c: &Client) {}
const BUCKET: &str = "differential-listing";
const KEYS: [&str; 3] = ["dir a/file+b%.txt", "markup &<>\"'", "~tilde"];
fn v2_fields(o: &aws_sdk_s3::operation::list_objects_v2::ListObjectsV2Output) -> Fields {
let keys: Vec<_> = o.contents().iter().map(|object| object.key()).collect();
vec![
("keys", format!("{keys:?}")),
("encoding_type", format!("{:?}", o.encoding_type())),
("key_count", format!("{:?}", o.key_count())),
("is_truncated", format!("{:?}", o.is_truncated())),
("has_next_token", format!("{}", o.next_continuation_token().is_some())),
]
}
fn v1_fields(o: &aws_sdk_s3::operation::list_objects::ListObjectsOutput) -> Fields {
let keys: Vec<_> = o.contents().iter().map(|object| object.key()).collect();
vec![
("keys", format!("{keys:?}")),
("marker", format!("{:?}", o.marker())),
("next_marker", format!("{:?}", o.next_marker())),
("encoding_type", format!("{:?}", o.encoding_type())),
]
}
pub(super) async fn cases(s: &mut Recorder, c: &Client) {
s.step("ListObjectsV2", "setup-bucket", c.create_bucket().bucket(BUCKET).send(), none)
.await;
for (key, case) in KEYS.into_iter().zip(["setup-object-1", "setup-object-2", "setup-object-3"]) {
let put = c
.put_object()
.bucket(BUCKET)
.key(key)
.body(ByteStream::from_static(b"x"))
.send();
s.step("ListObjectsV2", case, put, none).await;
}
let v2 = || c.list_objects_v2().bucket(BUCKET);
s.step("ListObjectsV2", "raw-keys", v2().send(), v2_fields).await;
s.step("ListObjectsV2", "url-encoded", v2().encoding_type(EncodingType::Url).send(), v2_fields)
.await;
let first = s
.step("ListObjectsV2", "first-page", v2().max_keys(2).send(), v2_fields)
.await;
let token = first.and_then(|page| page.next_continuation_token().map(str::to_owned));
s.step("ListObjectsV2", "next-page", v2().set_continuation_token(token).send(), v2_fields)
.await;
s.step("ListObjectsV2", "negative-max-keys", v2().max_keys(-1).send(), none)
.await;
s.step("ListObjectsV2", "undecodable-token", v2().continuation_token("%%%").send(), none)
.await;
let v1 = || c.list_objects().bucket(BUCKET).max_keys(1);
s.step("ListObjects", "raw-marker", v1().send(), v1_fields).await;
s.step(
"ListObjects",
"url-encoded-marker",
v1().encoding_type(EncodingType::Url).send(),
v1_fields,
)
.await;
s.step("ListObjects", "request-marker", v1().marker(KEYS[0]).send(), v1_fields)
.await;
s.step("ListObjects", "negative-max-keys", v1().max_keys(-1).send(), none)
.await;
let create = c.create_multipart_upload().bucket(BUCKET).key(KEYS[0]).send();
s.step("ListMultipartUploads", "setup-upload", create, none).await;
let uploads = || c.list_multipart_uploads().bucket(BUCKET);
s.step("ListMultipartUploads", "raw-keys", uploads().send(), upload_fields)
.await;
let encoded = uploads().prefix("dir a/").encoding_type(EncodingType::Url).send();
s.step("ListMultipartUploads", "url-encoded", encoded, upload_fields).await;
s.step("ListMultipartUploads", "zero-max-uploads", uploads().max_uploads(0).send(), none)
.await;
let foreign = uploads().prefix("dir").key_marker("other").send();
s.step("ListMultipartUploads", "foreign-key-marker", foreign, none).await;
}
fn upload_fields(o: &aws_sdk_s3::operation::list_multipart_uploads::ListMultipartUploadsOutput) -> Fields {
let keys: Vec<_> = o.uploads().iter().map(|upload| upload.key()).collect();
vec![
("keys", format!("{keys:?}")),
("prefix", format!("{:?}", o.prefix())),
("encoding_type", format!("{:?}", o.encoding_type())),
]
}
@@ -14,7 +14,106 @@
//! Differential cases of the `object_meta` batch (see `super`).
use super::super::Recorder;
use super::super::{Recorder, grants, none, tags};
use aws_sdk_s3::Client;
use aws_sdk_s3::primitives::ByteStream;
use aws_sdk_s3::types::{AccessControlPolicy, Grant, Grantee, Owner, Permission, Type};
pub(super) async fn cases(_s: &mut Recorder, _c: &Client) {}
const BUCKET: &str = "diff-object-meta";
const TAGGED: &str = "tagged";
pub(super) async fn cases(s: &mut Recorder, c: &Client) {
s.step("CreateBucket", "object-meta", c.create_bucket().bucket(BUCKET).send(), none)
.await;
let put = c
.put_object()
.bucket(BUCKET)
.key(TAGGED)
.tagging("k=&odd%20key=v%2Fw")
.body(ByteStream::from_static(b"object meta"));
s.step("PutObject", "object-meta-tagged", put.send(), none).await;
let get_tags = |key: &str, version: Option<&str>| {
c.get_object_tagging()
.bucket(BUCKET)
.key(key)
.set_version_id(version.map(str::to_owned))
};
s.step("GetObjectTagging", "empty-and-encoded-tags", get_tags(TAGGED, None).send(), |o| {
vec![("tags", tags(o.tag_set())), ("version", format!("{:?}", o.version_id()))]
})
.await;
s.step(
"GetObjectTagging",
"malformed-version",
get_tags(TAGGED, Some("not-a-version")).send(),
none,
)
.await;
let absent_version = "00000000-0000-0000-0000-000000000001";
s.step("GetObjectTagging", "absent-version", get_tags(TAGGED, Some(absent_version)).send(), none)
.await;
s.step("GetObjectTagging", "nul-key", get_tags("a\0b", None).send(), none)
.await;
s.step(
"DeleteObjectTagging",
"nul-key",
c.delete_object_tagging().bucket(BUCKET).key("a\0b").send(),
none,
)
.await;
s.step(
"DeleteObjectTagging",
"then-empty",
c.delete_object_tagging().bucket(BUCKET).key(TAGGED).send(),
none,
)
.await;
s.step("GetObjectTagging", "after-delete", get_tags(TAGGED, None).send(), |o| {
vec![("tags", tags(o.tag_set()))]
})
.await;
let grantee = Grantee::builder()
.r#type(Type::CanonicalUser)
.id("owner")
.build()
.expect("grantee");
let policy = AccessControlPolicy::builder()
.owner(Owner::builder().id("owner").build())
.grants(Grant::builder().grantee(grantee).permission(Permission::Read).build())
.build();
let xml_grants = c.put_object_acl().bucket(BUCKET).key(TAGGED).access_control_policy(policy);
s.step("PutObjectAcl", "xml-grants", xml_grants.send(), none).await;
s.step(
"GetObjectAcl",
"after-xml-grants",
c.get_object_acl().bucket(BUCKET).key(TAGGED).send(),
|o| vec![("grants", grants(o.grants()))],
)
.await;
s.step("GetObjectAcl", "nul-key", c.get_object_acl().bucket(BUCKET).key("a\0b").send(), none)
.await;
s.step(
"GetObjectLegalHold",
"no-object-lock",
c.get_object_legal_hold().bucket(BUCKET).key(TAGGED).send(),
none,
)
.await;
s.step(
"GetObjectRetention",
"no-object-lock",
c.get_object_retention().bucket(BUCKET).key(TAGGED).send(),
none,
)
.await;
s.step(
"GetObjectTorrent",
"nul-key",
c.get_object_torrent().bucket(BUCKET).key("a\0b").send(),
none,
)
.await;
}
@@ -14,7 +14,50 @@
//! Differential cases of the `object_misc` batch (see `super`).
use super::super::Recorder;
use super::super::{Recorder, none};
use aws_sdk_s3::Client;
use aws_sdk_s3::primitives::ByteStream;
use aws_sdk_s3::types::{BucketVersioningStatus, VersioningConfiguration};
pub(super) async fn cases(_s: &mut Recorder, _c: &Client) {}
const BUCKET: &str = "dual-stack-object-misc";
const KEY: &str = "doomed.txt";
/// DeleteObject on a versioned bucket: the delete marker and its headers, the delete of that
/// marker by version, and the refusals the delete raises before storage.
pub(super) async fn cases(s: &mut Recorder, c: &Client) {
s.step("CreateBucket", "object-misc-setup", c.create_bucket().bucket(BUCKET).send(), none)
.await;
let enabled = VersioningConfiguration::builder()
.status(BucketVersioningStatus::Enabled)
.build();
let versioning = c.put_bucket_versioning().bucket(BUCKET).versioning_configuration(enabled);
s.step("PutBucketVersioning", "object-misc-setup", versioning.send(), none)
.await;
let put = c.put_object().bucket(BUCKET).key(KEY).body(ByteStream::from_static(b"e2"));
s.step("PutObject", "object-misc-setup", put.send(), none).await;
let marker = s
.step(
"DeleteObject",
"creates-delete-marker",
c.delete_object().bucket(BUCKET).key(KEY).send(),
none,
)
.await
.and_then(|output| output.version_id().map(str::to_owned));
if let Some(marker) = marker {
let delete = c.delete_object().bucket(BUCKET).key(KEY).version_id(marker);
s.step("DeleteObject", "removes-delete-marker", delete.send(), none).await;
}
let delete = c.delete_object().bucket(BUCKET).key(KEY).version_id("not-a-version");
s.step("DeleteObject", "malformed-version", delete.send(), none).await;
let delete = c
.delete_object()
.bucket(BUCKET)
.key(KEY)
.customize()
.mutate_request(|request| {
request.headers_mut().insert("x-rustfs-force-delete", "maybe");
});
s.step("DeleteObject", "invalid-force-delete", delete.send(), none).await;
}
@@ -22,10 +22,11 @@ use rustfs_protos::{
models::PingBodyBuilder,
proto_gen::node_service::{
BatchGenerallyLockRequest, BatchGenerallyLockResponse, BatchReadVersionRequest, BatchReadVersionResponse,
GenerallyLockRequest, GenerallyLockResponse, GenerallyLockResult, PingRequest, PingResponse,
ScannerPublicationLeaseReleaseRequest, ScannerPublicationLeaseReleaseResponse, ScannerPublicationLeaseRequest,
ScannerPublicationLeaseResponse, SnapshotLeaseMutationResponse, SnapshotLeaseReleaseRequest, SnapshotLeaseRenewRequest,
SnapshotLeaseRequest, SnapshotLeaseResponse, node_service_server::NodeService,
GenerallyLockRequest, GenerallyLockResponse, GenerallyLockResult, MrfLifecycleRequest, MrfLifecycleResponse, PingRequest,
PingResponse, ScannerPublicationLeaseReleaseRequest, ScannerPublicationLeaseReleaseResponse,
ScannerPublicationLeaseRequest, ScannerPublicationLeaseResponse, SnapshotLeaseMutationResponse,
SnapshotLeaseReleaseRequest, SnapshotLeaseRenewRequest, SnapshotLeaseRequest, SnapshotLeaseResponse,
node_service_server::NodeService,
},
};
use std::pin::Pin;
@@ -438,6 +439,13 @@ impl NodeService for MinimalLockNodeService {
Err(Status::unimplemented("lock-only test server"))
}
async fn write_format_control(
&self,
_request: Request<rustfs_protos::proto_gen::node_service::WriteFormatControlRequest>,
) -> Result<Response<rustfs_protos::proto_gen::node_service::WriteAllResponse>, Status> {
Err(Status::unimplemented("lock-only test server"))
}
async fn compare_and_update_file(
&self,
_request: Request<rustfs_protos::proto_gen::node_service::CompareAndUpdateFileRequest>,
@@ -995,6 +1003,10 @@ impl NodeService for MinimalLockNodeService {
Err(Status::unimplemented("lock-only test server"))
}
async fn mrf_lifecycle(&self, _request: Request<MrfLifecycleRequest>) -> Result<Response<MrfLifecycleResponse>, Status> {
Err(Status::unimplemented("lock-only test server"))
}
async fn background_heal_status(
&self,
_request: Request<rustfs_protos::proto_gen::node_service::BackgroundHealStatusRequest>,
+49 -6
View File
@@ -412,6 +412,7 @@ struct ManualTransitionRunReport {
skipped_delete_marker: u64,
skipped_directory: u64,
skipped_replication: u64,
skipped_already_transitioned: u64,
skipped_already_in_flight: u64,
skipped_queue_full: u64,
skipped_queue_closed: u64,
@@ -1214,9 +1215,16 @@ async fn test_manual_transition_run_black_box_semantics() -> TestResult {
assert!(!due.report.dry_run);
assert!(due.report.lifecycle_config_found);
assert_eq!(due.report.scanned, 1, "due report: {:#?}", due.report);
assert_eq!(due.report.eligible, 1, "due report: {:#?}", due.report);
// PUT can enqueue this object before the manual scan. Account for each
// terminal outcome without depending on how fast the tier worker runs.
assert_eq!(
due.report.enqueued + due.report.skipped_already_in_flight,
due.report.eligible + due.report.skipped_already_transitioned,
1,
"due report: {:#?}",
due.report
);
assert_eq!(
due.report.enqueued + due.report.skipped_already_in_flight + due.report.skipped_already_transitioned,
1,
"due report: {:#?}",
due.report
@@ -1225,12 +1233,34 @@ async fn test_manual_transition_run_black_box_semantics() -> TestResult {
assert_eq!(due.report.skipped_delete_marker, 0);
assert_eq!(due.report.skipped_directory, 0);
assert_eq!(due.report.skipped_replication, 0);
assert_eq!(due.report.skipped_queue_full, 0);
assert_eq!(due.report.skipped_queue_closed, 0);
assert_eq!(due.report.skipped_queue_timeout, 0);
assert_eq!(due.report.tier_failure, 0);
assert!(!due.report.cancelled);
assert!(!due.report.truncated_by_limit);
assert!(!due.report.truncated_by_duration);
wait_for_transition(&hot_client, MANUAL_DUE_BUCKET, MANUAL_DUE_KEY, StdDuration::from_secs(90)).await?;
let remote_count_after_due = cold_tier_object_count(&cold_client).await?;
assert_eq!(remote_count_after_due, 1, "due object must have exactly one remote copy");
// Once HEAD observes the committed transition, a repeated manual scan must
// report the completed object and leave both local reads and the tier intact.
let repeated = manual_transition_run(&hot, MANUAL_DUE_BUCKET, "manual-due/", false).await?;
assert_eq!(repeated.state, "completed", "repeated report: {:#?}", repeated.report);
assert_eq!(repeated.report.scanned, 1, "repeated report: {:#?}", repeated.report);
assert_eq!(repeated.report.eligible, 0, "repeated report: {:#?}", repeated.report);
assert_eq!(repeated.report.enqueued, 0, "repeated report: {:#?}", repeated.report);
assert_eq!(repeated.report.skipped_already_transitioned, 1);
assert_eq!(repeated.report.skipped_already_in_flight, 0);
assert_eq!(cold_tier_object_count(&cold_client).await?, remote_count_after_due);
let due_object = hot_client
.get_object()
.bucket(MANUAL_DUE_BUCKET)
.key(MANUAL_DUE_KEY)
.send()
.await?;
assert_eq!(due_object.body.collect().await?.into_bytes().as_ref(), b"manual due object");
hot_client.create_bucket().bucket(MANUAL_DRY_RUN_BUCKET).send().await?;
enable_bucket_versioning(&hot_client, MANUAL_DRY_RUN_BUCKET).await?;
@@ -2286,6 +2316,14 @@ async fn test_manual_transition_run_continuation_token_resumes_without_raw_marke
)
.await?;
// Configuration updates enqueue existing due objects. Observe their commit
// before paging so eligibility stays stable across the source restart.
for idx in 0..2 {
let key = format!("{MANUAL_CONTINUATION_PREFIX}obj-{idx:02}");
wait_for_transition(&hot_client, MANUAL_CONTINUATION_BUCKET, &key, StdDuration::from_secs(90)).await?;
}
assert_eq!(cold_tier_object_count(&cold_client).await?, 2);
let first = manual_transition_run_with_max(&hot, MANUAL_CONTINUATION_BUCKET, MANUAL_CONTINUATION_PREFIX, true, 1).await?;
assert_eq!(first.state, "partial", "first continuation page: {first:#?}");
assert_eq!(first.mode, "enqueue_only");
@@ -2293,8 +2331,10 @@ async fn test_manual_transition_run_continuation_token_resumes_without_raw_marke
assert_eq!(first.report.prefix, MANUAL_CONTINUATION_PREFIX);
assert!(first.report.dry_run);
assert_eq!(first.report.scanned, 1, "first continuation page: {first:#?}");
assert_eq!(first.report.eligible, 1, "first continuation page: {first:#?}");
assert_eq!(first.report.dry_run_eligible, 1, "first continuation page: {first:#?}");
assert_eq!(first.report.eligible, 0, "first continuation page: {first:#?}");
assert_eq!(first.report.dry_run_eligible, 0, "first continuation page: {first:#?}");
assert_eq!(first.report.skipped_already_transitioned, 1);
assert_eq!(first.report.enqueued, 0);
assert_eq!(first.report.tier_failure, 0);
assert!(!first.report.cancelled);
assert!(first.report.truncated_by_limit);
@@ -2321,12 +2361,15 @@ async fn test_manual_transition_run_continuation_token_resumes_without_raw_marke
.await?;
assert_eq!(second.state, "completed", "second continuation page: {second:#?}");
assert_eq!(second.report.scanned, 1, "second continuation page: {second:#?}");
assert_eq!(second.report.eligible, 1, "second continuation page: {second:#?}");
assert_eq!(second.report.dry_run_eligible, 1, "second continuation page: {second:#?}");
assert_eq!(second.report.eligible, 0, "second continuation page: {second:#?}");
assert_eq!(second.report.dry_run_eligible, 0, "second continuation page: {second:#?}");
assert_eq!(second.report.skipped_already_transitioned, 1);
assert_eq!(second.report.enqueued, 0);
assert_eq!(second.report.tier_failure, 0);
assert!(!second.report.cancelled);
assert!(!second.report.truncated_by_limit);
assert!(second.report.continuation_token.is_none());
assert_eq!(cold_tier_object_count(&cold_client).await?, 2);
Ok(())
}
+46 -9
View File
@@ -208,7 +208,8 @@ pub mod bucket {
pub mod durability {
pub use crate::bucket::durability::{
BUCKET_DURABILITY_MODE_NONE, BUCKET_DURABILITY_MODE_RELAXED, BUCKET_DURABILITY_MODE_STRICT, BucketDurabilityConfig,
BUCKET_DURABILITY_MODE_FILE_SYNC, BUCKET_DURABILITY_MODE_NONE, BUCKET_DURABILITY_MODE_RELAXED,
BUCKET_DURABILITY_MODE_STRICT, BucketDurabilityConfig,
};
}
@@ -502,7 +503,7 @@ pub mod disk {
QUOTA_MUTATION_FENCE_METADATA_SUFFIX, RUSTFS_META_BUCKET, RUSTFS_META_MULTIPART_BUCKET, RUSTFS_META_TMP_BUCKET,
ReadMultipleReq, ReadMultipleResp, ReadOptions, RenameDataResp, STORAGE_FORMAT_FILE, SnapshotLeaseToken,
UpdateMetadataOpts, VolumeInfo, WalkDirOptions, is_quota_mutation_fence_path, new_disk,
validate_batch_read_version_item_count,
validate_batch_read_version_item_count, validate_format_control_path,
};
pub use crate::disk::{
BackgroundMemoryBudget, PhysicalDiskBinding, PhysicalDiskPlan, PhysicalDiskSample, PhysicalDiskSampler,
@@ -565,6 +566,10 @@ pub mod runtime {
global_lock_client, global_lock_clients, global_tier_config_mgr, local_disk_map_read, object_store_handle, region,
rustfs_port, setup_is_dist_erasure, setup_is_erasure, setup_is_erasure_sd, transition_state_handle,
};
pub use crate::runtime::usage_watch::{
SCANNER_USAGE_WATCH_COVERAGE_VERSION, SCANNER_USAGE_WATCH_LEASE_MS, ScannerUsageWatchKnown, ScannerUsageWatchObservation,
ScannerUsageWatchRequest,
};
}
pub mod layout {
@@ -653,6 +658,25 @@ pub mod rio {
}
pub mod rpc {
#[cfg(all(feature = "test-util", feature = "internode-transport"))]
pub mod test_util {
/// Build a remote disk using a controlled transport and no health monitor.
///
/// # Errors
/// Returns the normal remote-disk construction error for the supplied endpoint.
pub async fn remote_disk_with_transport(
endpoint: &crate::layout::endpoint::Endpoint,
transport: std::sync::Arc<dyn super::InternodeDataTransport>,
) -> crate::disk::error::Result<crate::disk::DiskStore> {
let options = crate::disk::DiskOption {
cleanup: false,
health_check: false,
};
let disk = crate::cluster::rpc::remote_disk::RemoteDisk::new(endpoint, &options, transport).await?;
Ok(std::sync::Arc::new(crate::disk::Disk::Remote(Box::new(disk))))
}
}
#[cfg(feature = "internode-transport")]
pub use crate::cluster::rpc::http_auth::ExternalStreamAuth;
pub use crate::cluster::rpc::http_auth::with_rpc_background_request;
@@ -661,6 +685,15 @@ pub mod rpc {
InternodeDataTransport, InternodeDataTransportCapabilities, NsScannerCapabilityRequest, NsScannerStreamRequest,
ReadStreamRequest, TcpHttpInternodeDataTransport, WalkDirStreamRequest, WriteStreamRequest,
};
/// Internode shard reads over NIXL: the receive-pool seam the binary fills
/// and the wire names its serving handler shares with the transport.
pub mod nixl {
pub use crate::cluster::rpc::nixl_internode::{
NIXL_AGENT_QUERY, NIXL_BUFFER_QUERY, NIXL_BUFFERS_QUERY, NIXL_BYTES_HEADER, NIXL_METADATA_HEADER,
NIXL_METADATA_SHA256_QUERY, NIXL_NONCE_QUERY, NixlRecvBuffer, NixlRecvPool, READ_FILE_NIXL_PATH,
WRITE_FILE_NIXL_PATH, install_nixl_recv_pool,
};
}
pub use crate::cluster::rpc::{
AuthenticatedChannel, KMS_SIGNAL_SUBSYSTEM, LocalPeerS3Client, MAX_NETWORK_PROBE_BYTES, MAX_NETWORK_PROBE_DURATION,
NetworkPeerProbeClient, NetworkPeerProbeError, NetworkPeerProbeMeasurement, NetworkPeerTarget, PEER_RESTDRY_RUN,
@@ -672,13 +705,17 @@ pub mod rpc {
gen_tonic_replay_scope_headers, gen_tonic_signature_headers, gen_tonic_signature_interceptor,
node_service_time_out_client, node_service_time_out_client_no_auth, normalize_tonic_rpc_audience,
rpc_auth_is_resource_exhausted, rpc_background_admission, set_tonic_canonical_body_digest, sign_ns_scanner_capability,
sign_ns_scanner_capability_with_checkpoint_coverage, sign_ns_scanner_capability_with_tier_registry_generation,
sign_put_file_capability, sign_tonic_rpc_response_proof, tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers,
tonic_rpc_auth_failure_reason, verify_ns_scanner_capability, verify_ns_scanner_capability_with_checkpoint_coverage,
verify_ns_scanner_capability_with_tier_registry_generation, verify_put_file_auth_trailer, verify_put_file_capability,
verify_rpc_signature, verify_tonic_boot_epoch_response, verify_tonic_canonical_body_digest,
verify_tonic_mutation_body_digest, verify_tonic_mutation_body_digest_reject_unsigned, verify_tonic_rpc_response_proof,
verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
sign_ns_scanner_capability_with_checkpoint_coverage, sign_ns_scanner_capability_with_durable_progress,
sign_ns_scanner_capability_with_tier_registry_generation, sign_ns_scanner_capability_with_usage_capabilities,
sign_ns_scanner_usage_watch_capability, sign_put_file_capability, sign_tonic_rpc_response_proof,
tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers, tonic_boot_epoch_response_headers_with_msgpack_capability,
tonic_msgpack_manifest_capability_requested, tonic_rpc_auth_failure_reason, verify_ns_scanner_capability,
verify_ns_scanner_capability_with_checkpoint_coverage, verify_ns_scanner_capability_with_durable_progress,
verify_ns_scanner_capability_with_tier_registry_generation, verify_ns_scanner_capability_with_usage_capabilities,
verify_ns_scanner_usage_watch_capability, verify_put_file_auth_trailer, verify_put_file_capability, verify_rpc_signature,
verify_tonic_boot_epoch_response, verify_tonic_canonical_body_digest, verify_tonic_mutation_body_digest,
verify_tonic_mutation_body_digest_reject_unsigned, verify_tonic_rpc_response_proof, verify_tonic_rpc_signature,
verify_tonic_rpc_signature_with_bootstrap,
};
}
+110 -4
View File
@@ -26,6 +26,8 @@ use crate::bucket::target::BucketTargetType;
use crate::bucket::target::{self, BucketTarget, BucketTargets, Credentials};
use crate::bucket::versioning_sys::BucketVersioningSys;
use crate::runtime::sources as runtime_sources;
use aws_sdk_s3::config::interceptors::BeforeDeserializationInterceptorContextRef;
use aws_sdk_s3::config::{ConfigBag, Intercept, RuntimeComponents};
use aws_sdk_s3::error::ProvideErrorMetadata;
use aws_sdk_s3::error::SdkError;
use aws_sdk_s3::operation::complete_multipart_upload::CompleteMultipartUploadOutput;
@@ -53,8 +55,9 @@ use http::{HeaderMap, HeaderName, HeaderValue, StatusCode};
use reqwest::Client as HttpClient;
use rustfs_utils::http::{
AMZ_BUCKET_REPLICATION_STATUS, AMZ_OBJECT_LOCK_BYPASS_GOVERNANCE, AMZ_OBJECT_LOCK_LEGAL_HOLD, AMZ_OBJECT_LOCK_MODE,
AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE, AMZ_OBJECT_TAGGING_LOWER, AMZ_STORAGE_CLASS, AMZ_WEBSITE_REDIRECT_LOCATION, is_amz_header,
is_minio_header, is_rustfs_header, is_standard_header, is_storageclass_header,
AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE, AMZ_OBJECT_TAGGING, AMZ_OBJECT_TAGGING_LOWER, AMZ_STORAGE_CLASS,
AMZ_TAGGING_DIRECTIVE_LOWER, AMZ_WEBSITE_REDIRECT_LOCATION, is_amz_header, is_minio_header, is_rustfs_header,
is_standard_header, is_storageclass_header,
};
use rustfs_utils::http::{
SUFFIX_FORCE_DELETE, SUFFIX_SOURCE_DELETEMARKER, SUFFIX_SOURCE_ETAG, SUFFIX_SOURCE_MTIME, SUFFIX_SOURCE_PROXY_REQUEST,
@@ -132,6 +135,36 @@ impl From<&BucketTarget> for RemoteS3EndpointSpec {
pub type HeadObjectSdkError = Box<SdkError<HeadObjectError>>;
/// Captures the `x-amz-tagging` response header of a replication HEAD, which
/// the SDK drops while deserializing `HeadObjectOutput`.
#[derive(Clone, Debug, Default)]
struct HeadObjectTaggingCapture(Arc<std::sync::Mutex<Option<String>>>);
impl HeadObjectTaggingCapture {
fn take(&self) -> Option<String> {
self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner).take()
}
}
impl Intercept for HeadObjectTaggingCapture {
fn name(&self) -> &'static str {
"HeadObjectTaggingCapture"
}
fn read_before_deserialization(
&self,
context: &BeforeDeserializationInterceptorContextRef<'_>,
_runtime_components: &RuntimeComponents,
_cfg: &mut ConfigBag,
) -> Result<(), aws_sdk_s3::error::BoxError> {
// Overwrite on every attempt so a retried HEAD reports the tags of the
// response that was actually deserialized.
*self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner) =
context.response().headers().get(AMZ_OBJECT_TAGGING_LOWER).map(str::to_string);
Ok(())
}
}
/// Whether an edited bucket target still addresses the same remote service
/// (endpoint, bucket, path style, TLS and identity), so a verdict learned
/// about that service stays valid across the edit.
@@ -2100,12 +2133,19 @@ impl TargetClient {
// object with an identical ETag, and the worker concludes the object
// already converged — so it never actually replicates it.
insert_header(&mut headers, SUFFIX_SOURCE_PROXY_REQUEST, "false");
self.client
// Ask for the tag set itself (MinIO `x-amz-tagging-directive: ACCESS`):
// a plain HEAD reports only the tag count, which cannot tell the
// replica's tags from the source's.
headers.insert(HeaderName::from_static(AMZ_TAGGING_DIRECTIVE_LOWER), HeaderValue::from_static("ACCESS"));
let target_tagging = HeadObjectTaggingCapture::default();
let mut output = self
.client
.head_object()
.bucket(bucket)
.key(object)
.set_version_id(resolve_read_api_version_id(version_id))
.customize()
.interceptor(target_tagging.clone())
.map_request(move |mut req| {
for (k, v) in headers.clone().into_iter() {
if let Some(key_str) = k.map(|k| k.as_str().to_string()) {
@@ -2117,7 +2157,17 @@ impl TargetClient {
})
.send()
.await
.map_err(Box::new)
.map_err(Box::new)?;
// The SDK's typed output has no field for the tag set; carry it where
// the replication comparison reads it. A target that ignores the
// directive leaves the key absent, which compares as "tags unknown".
if let Some(tagging) = target_tagging.take() {
output
.metadata
.get_or_insert_default()
.insert(AMZ_OBJECT_TAGGING.to_string(), tagging);
}
Ok(output)
}
/// Candidate replicas by content identity on a target that mints its own
@@ -4556,6 +4606,62 @@ mod tests {
);
}
#[derive(Clone, Debug)]
struct TaggingHeadConnector {
target_tagging: Option<&'static str>,
tagging_directives: Arc<std::sync::Mutex<Vec<Option<String>>>>,
}
impl SmithyHttpConnector for TaggingHeadConnector {
fn call(&self, request: HttpRequest) -> HttpConnectorFuture {
self.tagging_directives
.lock()
.expect("recorded directive lock should not be poisoned")
.push(request.headers().get(AMZ_TAGGING_DIRECTIVE_LOWER).map(str::to_string));
let mut response = HttpResponse::new(
aws_smithy_runtime_api::http::StatusCode::try_from(200_u16).expect("200 should be a valid response status"),
SdkBody::empty(),
);
response.headers_mut().insert("x-amz-meta-owner", "team-a");
if let Some(tagging) = self.target_tagging {
response.headers_mut().insert(AMZ_OBJECT_TAGGING_LOWER, tagging);
}
HttpConnectorFuture::ready(Ok(response))
}
}
#[tokio::test]
async fn head_object_requests_and_reports_the_target_tag_set() {
for target_tagging in [Some("env=prod&team=a"), None] {
let tagging_directives = Arc::new(std::sync::Mutex::new(Vec::new()));
let connector = SharedHttpConnector::new(TaggingHeadConnector {
target_tagging,
tagging_directives: Arc::clone(&tagging_directives),
});
let http_client = http_client_fn(move |_settings, _components| connector.clone());
let (mut client, _) = recording_target_client();
client.client = Arc::new(s3_client_for_test(443, Some(http_client)));
let head = client
.head_object("target-bucket", "object", None)
.await
.expect("canned HEAD should succeed");
assert_eq!(
*tagging_directives
.lock()
.expect("recorded directive lock should not be poisoned"),
vec![Some("ACCESS".to_string())],
"the replication HEAD must ask the target for its tag set"
);
let metadata = head.metadata.expect("user metadata should be parsed");
assert_eq!(metadata.get("owner").map(String::as_str), Some("team-a"));
// Absent means "tags unknown": the comparison then keeps treating a
// tagged replica as different instead of trusting the count alone.
assert_eq!(metadata.get(AMZ_OBJECT_TAGGING).map(String::as_str), target_tagging);
}
}
#[tokio::test]
async fn put_object_sends_source_version_id_query_to_target() {
// MinIO reads the replicated version only from the `versionId` query
+90 -5
View File
@@ -22,12 +22,13 @@
//! `.minio.sys`) can never carry an override; they stay pinned to `strict`.
//! See docs/operations/durability-modes.md for the semantics.
use serde::{Deserialize, Serialize};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
/// Valid per-bucket durability tier names. `legacy-off` is deliberately not
/// representable per bucket: it exists only for the process-wide legacy
/// switch (`RUSTFS_DRIVE_SYNC_ENABLE=false`).
pub const BUCKET_DURABILITY_MODE_STRICT: &str = "strict";
pub const BUCKET_DURABILITY_MODE_FILE_SYNC: &str = "file-sync";
pub const BUCKET_DURABILITY_MODE_RELAXED: &str = "relaxed";
pub const BUCKET_DURABILITY_MODE_NONE: &str = "none";
@@ -35,14 +36,69 @@ pub const BUCKET_DURABILITY_MODE_NONE: &str = "none";
///
/// An absent entry, an empty payload, or an empty `mode` string all mean
/// "no override": the bucket follows the process-wide durability mode.
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct BucketDurabilityConfig {
/// Requested tier: `strict` | `relaxed` | `none` (case-insensitive,
/// Requested tier: `strict` | `file-sync` | `relaxed` | `none` (case-insensitive,
/// whitespace-tolerant). Empty means "inherit the global mode".
#[serde(default)]
pub mode: String,
}
#[derive(Serialize)]
struct BucketDurabilityConfigWireRef<'a> {
mode: &'a str,
#[serde(skip_serializing_if = "is_false")]
file_sync: bool,
}
fn is_false(value: &bool) -> bool {
!*value
}
#[derive(Deserialize)]
struct BucketDurabilityConfigWire {
#[serde(default)]
mode: String,
#[serde(default)]
file_sync: bool,
}
impl Serialize for BucketDurabilityConfig {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let file_sync = self.mode.trim().eq_ignore_ascii_case(BUCKET_DURABILITY_MODE_FILE_SYNC);
BucketDurabilityConfigWireRef {
mode: if file_sync {
BUCKET_DURABILITY_MODE_STRICT
} else {
&self.mode
},
file_sync,
}
.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for BucketDurabilityConfig {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let wire = BucketDurabilityConfigWire::deserialize(deserializer)?;
let mode = if wire.file_sync {
if wire.mode.trim().eq_ignore_ascii_case(BUCKET_DURABILITY_MODE_STRICT) {
BUCKET_DURABILITY_MODE_FILE_SYNC.to_string()
} else {
BUCKET_DURABILITY_MODE_STRICT.to_string()
}
} else {
wire.mode
};
Ok(Self { mode })
}
}
impl BucketDurabilityConfig {
pub fn new(mode: &str) -> Self {
Self { mode: mode.to_string() }
@@ -52,7 +108,10 @@ impl BucketDurabilityConfig {
pub fn is_valid_mode(mode: &str) -> bool {
matches!(
mode.trim().to_ascii_lowercase().as_str(),
BUCKET_DURABILITY_MODE_STRICT | BUCKET_DURABILITY_MODE_RELAXED | BUCKET_DURABILITY_MODE_NONE
BUCKET_DURABILITY_MODE_STRICT
| BUCKET_DURABILITY_MODE_FILE_SYNC
| BUCKET_DURABILITY_MODE_RELAXED
| BUCKET_DURABILITY_MODE_NONE
)
}
@@ -117,6 +176,7 @@ mod tests {
#[test]
fn valid_modes_are_recognized() {
assert!(BucketDurabilityConfig::is_valid_mode("strict"));
assert!(BucketDurabilityConfig::is_valid_mode("file-sync"));
assert!(BucketDurabilityConfig::is_valid_mode("relaxed"));
assert!(BucketDurabilityConfig::is_valid_mode("none"));
assert!(BucketDurabilityConfig::is_valid_mode(" RELAXED "));
@@ -130,6 +190,7 @@ mod tests {
fn normalized_mode_canonicalizes_or_rejects() {
assert_eq!(BucketDurabilityConfig::new(" Relaxed ").normalized_mode().as_deref(), Some("relaxed"));
assert_eq!(BucketDurabilityConfig::new("strict").normalized_mode().as_deref(), Some("strict"));
assert_eq!(BucketDurabilityConfig::new(" FILE-SYNC ").normalized_mode().as_deref(), Some("file-sync"));
assert_eq!(BucketDurabilityConfig::default().normalized_mode(), None);
assert_eq!(BucketDurabilityConfig::new("bogus").normalized_mode(), None);
}
@@ -141,11 +202,34 @@ mod tests {
let back: BucketDurabilityConfig = serde_json::from_slice(&json).expect("deserialize");
assert_eq!(back, cfg);
let file_sync = BucketDurabilityConfig::new("file-sync");
let json = serde_json::to_vec(&file_sync).expect("serialize file-sync");
assert_eq!(json, br#"{"mode":"strict","file_sync":true}"#);
let back: BucketDurabilityConfig = serde_json::from_slice(&json).expect("deserialize file-sync");
assert_eq!(back.normalized_mode().as_deref(), Some("file-sync"));
let malformed = serde_json::from_slice::<BucketDurabilityConfig>(br#"{"mode":"none","file_sync":true}"#)
.expect("deserialize malformed file-sync");
assert_eq!(malformed.normalized_mode().as_deref(), Some("strict"));
// Empty object deserializes to the "inherit" default.
let empty: BucketDurabilityConfig = serde_json::from_slice(b"{}").expect("deserialize empty");
assert_eq!(empty.normalized_mode(), None);
}
#[test]
fn file_sync_encoding_fails_closed_on_legacy_readers() {
#[derive(Deserialize)]
struct LegacyConfig {
#[serde(default)]
mode: String,
}
let json = serde_json::to_vec(&BucketDurabilityConfig::new("file-sync")).expect("serialize file-sync");
let legacy: LegacyConfig = serde_json::from_slice(&json).expect("legacy reader should ignore the marker");
assert_eq!(legacy.mode, "strict", "legacy readers must apply the stronger strict fallback");
}
#[test]
fn new_bucket_default_inherits_when_unset() {
temp_env::with_var_unset(ENV_NEW_BUCKET_DURABILITY_MODE, || {
@@ -157,6 +241,7 @@ mod tests {
fn new_bucket_default_honors_explicit_tiers() {
for mode in [
BUCKET_DURABILITY_MODE_STRICT,
BUCKET_DURABILITY_MODE_FILE_SYNC,
BUCKET_DURABILITY_MODE_RELAXED,
BUCKET_DURABILITY_MODE_NONE,
] {
@@ -4066,6 +4066,11 @@ pub async fn enqueue_transition_immediate(oi: &ObjectInfo, src: LcEventSrc) {
}
pub(crate) async fn enqueue_immediate_expiry(api: Arc<ECStore>, oi: &ObjectInfo, src: LcEventSrc, opts: &ObjectOptions) {
// Without a lifecycle document there is nothing to expire; skip the
// metadata-transaction lock and incarnation read that only validate it.
if !metadata_boundary::cached_metadata_may_have_lifecycle(&api, &oi.bucket).await {
return;
}
let configs = match metadata_boundary::get_expiry_configs_for_options(&api, &oi.bucket, opts).await {
Ok(configs) => configs,
Err(err) => {
@@ -13569,6 +13574,105 @@ mod tests {
);
}
#[tokio::test]
#[serial]
async fn immediate_expiry_without_lifecycle_skips_metadata_transaction() {
let (_paths, ecstore) = setup_test_env().await;
let bucket = format!("lifecycle-absent-expiry-{}", Uuid::new_v4().simple());
create_test_bucket(&ecstore, &bucket).await;
let oi = ecstore
.put_object(
&bucket,
"object",
&mut PutObjReader::from_vec(b"payload".to_vec()),
&ObjectOptions::default(),
)
.await
.expect("create object without lifecycle");
let state = install_unconsumed_runtime_expiry_worker(&ecstore, 4).await;
let transaction = ecstore
.new_ns_lock(
crate::disk::RUSTFS_META_BUCKET,
&metadata_sys::bucket_metadata_transaction_lock_key(&bucket),
)
.await
.expect("metadata transaction namespace");
let opts = ObjectOptions::default();
// A configuration writer outlasts the hook's lock wait; without
// lifecycle there is no incarnation to validate.
let writer = transaction
.get_write_lock(StdDuration::from_secs(5))
.await
.expect("hold metadata transaction");
tokio::time::timeout(
StdDuration::from_secs(1),
super::enqueue_immediate_expiry(Arc::clone(&ecstore), &oi, LcEventSrc::S3PutObject, &opts),
)
.await
.expect("no lifecycle must not wait for the metadata transaction");
assert_eq!(state.read().await.stats.pending_tasks(), 0, "nothing to expire");
drop(writer);
// An unreadable lifecycle document keeps the authoritative path, which
// reports the metadata failure instead of treating it as absent.
let sys = metadata_sys::bucket_metadata_sys_of(&ecstore.ctx).expect("metadata system");
let sys = sys.read().await.clone();
let mut metadata = (*sys.get(&bucket).await.expect("bucket metadata")).clone();
metadata.lifecycle_config_xml = b"<LifecycleConfiguration>".to_vec();
metadata.lifecycle_config = None;
sys.persist_and_set(metadata).await.expect("persist unreadable lifecycle");
let observed = Arc::new(StdMutex::new(Vec::new()));
let observed_events = Arc::clone(&observed);
let _observer = set_lifecycle_observability_observer(move |event, state, reason| {
observed_events
.lock()
.expect("lifecycle observer should not poison")
.push((event, state, reason));
});
super::enqueue_immediate_expiry(Arc::clone(&ecstore), &oi, LcEventSrc::S3PutObject, &opts).await;
assert!(
observed.lock().expect("observed events should not poison").contains(&(
EVENT_LIFECYCLE_EVALUATION_FAILED,
"failed",
Some("metadata_unavailable")
)),
"an unreadable lifecycle document must keep the authoritative path"
);
assert_eq!(state.read().await.stats.pending_tasks(), 0, "nothing enqueued");
}
#[tokio::test]
#[serial]
async fn cached_lifecycle_check_keeps_creation_pending_and_uncached_buckets() {
let (_paths, ecstore) = setup_test_env().await;
let bucket = format!("lifecycle-cached-check-{}", Uuid::new_v4().simple());
create_test_bucket(&ecstore, &bucket).await;
let sys = metadata_sys::bucket_metadata_sys_of(&ecstore.ctx).expect("metadata system");
let sys = sys.read().await.clone();
assert!(
!super::metadata_boundary::cached_metadata_may_have_lifecycle(&ecstore, &bucket).await,
"a cached bucket without lifecycle skips the lookup"
);
let mut pending = (*sys.get(&bucket).await.expect("bucket metadata")).clone();
pending.lock_enabled = true;
pending.bucket_incarnation_sidecar = true;
pending.bucket_creation_committed = false;
assert!(pending.needs_bucket_creation_commit(), "fixture is creation-pending");
sys.set(bucket.clone(), Arc::new(pending)).await;
assert!(
super::metadata_boundary::cached_metadata_may_have_lifecycle(&ecstore, &bucket).await,
"a creation-pending bucket keeps the migration path"
);
assert!(sys.remove(&bucket).await, "cached entry removed");
assert!(
super::metadata_boundary::cached_metadata_may_have_lifecycle(&ecstore, &bucket).await,
"an uncached bucket keeps the authoritative path"
);
}
#[tokio::test]
#[serial]
async fn lifecycle_expiry_fails_closed_on_corrupt_object_lock_metadata() {
@@ -55,6 +55,25 @@ pub(crate) async fn lifecycle_expiry_allowed(
.table_bucket_enabled())
}
/// `get_expiry_configs_for_options` takes the lifecycle rules from this same
/// cached entry and reads the bucket incarnation only to validate it, so a
/// cached entry without any lifecycle document cannot produce an expiry.
/// Uncached, fabricated and creation-pending buckets keep the full path.
pub(crate) async fn cached_metadata_may_have_lifecycle(api: &crate::store::ECStore, bucket: &str) -> bool {
let Ok(sys) = metadata_sys::bucket_metadata_sys_of(&api.ctx) else {
return true;
};
let sys = sys.read().await.clone();
match sys.get(bucket).await {
Ok(metadata) => {
metadata.needs_bucket_creation_commit()
|| metadata.lifecycle_config.is_some()
|| !metadata.lifecycle_config_xml.is_empty()
}
Err(_) => true,
}
}
pub(crate) async fn get_expiry_configs(api: &crate::store::ECStore, bucket: &str) -> Result<LifecycleExpiryConfigs> {
get_expiry_configs_for_options(api, bucket, &crate::object_api::ObjectOptions::default()).await
}
@@ -20,6 +20,8 @@ use crate::test_metrics::CapturingRecorder;
use rustfs_data_usage::{BucketUsageInfo, DataUsageInfo};
use std::time::SystemTime;
mod native_compatibility;
async fn stop_reporting_fixture(store: &crate::store::ECStore) {
if let Some(cancel) = store.ctx.background_cancel_token() {
cancel.cancel();
@@ -90,6 +92,10 @@ async fn install_reporting_snapshot(
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn durable_quota_reporting_retires_degraded_floors_without_changing_ledger_admission() {
assert_durable_quota_reporting_preserves_admission().await;
}
async fn assert_durable_quota_reporting_preserves_admission() {
let recorder = CapturingRecorder::default();
let _recorder = metrics::set_default_local_recorder(&recorder);
for protocol in [1, 2] {
@@ -196,6 +202,11 @@ async fn durable_quota_reporting_retires_degraded_floors_without_changing_ledger
.expect("fixture cache cleanup");
crate::data_usage::invalidate_data_usage_snapshot_cache().await;
stop_reporting_fixture(&store).await;
for dir in _dirs {
let path = dir.path().to_path_buf();
dir.close().expect("remove durable quota reporting fixture");
assert!(!path.exists());
}
}
}
}
@@ -203,6 +214,10 @@ async fn durable_quota_reporting_retires_degraded_floors_without_changing_ledger
#[tokio::test]
#[serial]
async fn snapshot_quota_admission_retains_degraded_floors_until_migration() {
assert_snapshot_quota_preserves_degraded_floors().await;
}
async fn assert_snapshot_quota_preserves_degraded_floors() {
for source in ["missing", "legacy", "incomplete", "observed"] {
let (_dirs, store, _) = isolated_durable_quota_store().await;
let bucket = format!("quota-compat-{}", Uuid::new_v4().simple());
@@ -233,12 +248,21 @@ async fn snapshot_quota_admission_retains_degraded_floors_until_migration() {
.expect("fixture cache cleanup");
crate::data_usage::invalidate_data_usage_snapshot_cache().await;
stop_reporting_fixture(&store).await;
for dir in _dirs {
let path = dir.path().to_path_buf();
dir.close().expect("remove legacy quota reporting fixture");
assert!(!path.exists());
}
}
}
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn quota_without_limit_keeps_the_zero_usage_io_fast_path() {
assert_unlimited_quota_preserves_fast_path().await;
}
async fn assert_unlimited_quota_preserves_fast_path() {
let (_dirs, store, sys) = isolated_durable_quota_store().await;
let bucket = format!("quota-unlimited-{}", Uuid::new_v4().simple());
create_bucket_with_quota_json(
@@ -259,6 +283,11 @@ async fn quota_without_limit_keeps_the_zero_usage_io_fast_path() {
assert_eq!(recorder.counter_value(METRIC_QUOTA_USAGE_REPORT_UNAVAILABLE_TOTAL, &[]), 0);
assert_eq!(crate::data_usage::reload_unknown_bucket_usage_calls_for_test(&bucket), 0);
stop_reporting_fixture(&store).await;
for dir in _dirs {
let path = dir.path().to_path_buf();
dir.close().expect("remove unlimited quota reporting fixture");
assert!(!path.exists());
}
}
#[tokio::test]
@@ -0,0 +1,265 @@
// Copyright 2026 RustFS Team
// SPDX-License-Identifier: Apache-2.0
use super::*;
use crate::storage_api_contracts::bucket::{BucketOperations as _, MakeBucketOptions};
use rustfs_data_usage::{
DATA_USAGE_BUCKET_OBSERVATION_VERSION, DataUsageBucketObservation, DataUsageBucketObservationSource,
DataUsageSnapshotSetState,
};
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn usage_quota_modes_preserve_actual_admission_decisions() {
let (dirs, store, sys) = isolated_durable_quota_store().await;
let bucket = format!("usage-no-quota-{}", Uuid::new_v4().simple());
store
.make_bucket(&bucket, &MakeBucketOptions::default())
.await
.expect("unconfigured quota bucket");
let check = QuotaChecker::new(sys)
.check_quota(&bucket, QuotaOperation::PutObject, u64::MAX)
.await
.expect("no quota");
assert!(check.allowed && check.quota_limit.is_none());
store
.put_object(
&bucket,
"allowed",
&mut PutObjReader::from_vec(vec![0x5a; 512]),
&ObjectOptions::default(),
)
.await
.expect("real no-quota write");
stop_reporting_fixture(&store).await;
let paths = dirs.iter().map(|dir| dir.path().to_path_buf()).collect::<Vec<_>>();
drop(store);
drop(dirs);
assert!(paths.iter().all(|path| !path.exists()));
assert_unlimited_quota_preserves_fast_path().await;
assert_snapshot_quota_preserves_degraded_floors().await;
assert_durable_quota_reporting_preserves_admission().await;
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-19", "assertion_id": "USAGE-19-A01", "status": "PASS",
"evidence": {
"quota_modes": ["unconfigured", "unlimited", "legacy-snapshot", "durable-v1", "durable-v2"],
"durable_snapshot_sources": ["missing", "legacy", "incomplete", "observed", "complete"],
"durable_storage_decisions_per_fixture": ["reject-8192", "accept-512", "accept-3584", "reject-1"],
"legacy_missing_baseline_fails_closed": true,
"legacy_grounded_baselines": ["legacy", "incomplete", "observed"]
}
})
);
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-19", "status": "PASS", "fixtures_removed": true})
);
}
async fn persist_companion_fixture(
store: Arc<crate::store::ECStore>,
bucket: &str,
primary: bool,
companion_size: u64,
) -> (String, Vec<u8>) {
let incarnation = store
.bucket_incarnation_id_from_disk(bucket)
.await
.expect("real companion bucket identity");
let completed_at = SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(20);
let mut snapshot = DataUsageInfo {
last_update: Some(completed_at),
scanner_epoch: Some(2),
scanner_cycle: Some(3),
usage_snapshot_complete: primary,
usage_snapshot_partial: !primary,
usage_snapshot_observational: true,
usage_snapshot_converged: Some(false),
usage_snapshot_authoritative_baseline: Some(DataUsageInfo::default().snapshot_identity()),
usage_snapshot_pending_buckets: vec![bucket.to_owned()],
usage_snapshot_pending_bucket_count: 1,
usage_snapshot_set_states: vec![DataUsageSnapshotSetState {
pool_index: 0,
set_index: 0,
scanner_epoch: Some(2),
scanner_cycle: Some(3),
scan_plan_digest: Some([1; 32]),
complete: primary,
..Default::default()
}],
..Default::default()
};
if primary {
snapshot.buckets_count = 1;
snapshot.buckets_usage.insert(
bucket.into(),
BucketUsageInfo {
size: 1000,
objects_count: 1,
versions_count: 1,
bucket_incarnation: Some(incarnation.to_string()),
..Default::default()
},
);
snapshot.bucket_sizes.insert(bucket.into(), 1000);
snapshot.calculate_totals();
}
let mut usage = BucketUsageInfo {
size: companion_size,
objects_count: 1,
versions_count: 1,
bucket_incarnation: Some(incarnation.to_string()),
..Default::default()
};
usage.mark_observed();
snapshot.usage_snapshot_bucket_observations.insert(
bucket.into(),
DataUsageBucketObservation {
version: DATA_USAGE_BUCKET_OBSERVATION_VERSION,
usage,
snapshot_identity: snapshot.snapshot_identity(),
completed_at,
sources: vec![DataUsageBucketObservationSource {
pool_index: 0,
set_index: 0,
bucket_incarnation: incarnation.to_string(),
scanner_epoch: 2,
scanner_cycle: 3,
scan_plan_digest: [1; 32],
started_plan: [2; 32],
requested_plan: [3; 32],
completed_at,
}],
},
);
let mut admin = snapshot.clone();
assert_eq!(
admin.project_bucket_observations_for_admin(&HashMap::from([(bucket.to_owned(), incarnation.to_string())])),
1,
"the companion must be valid, not discarded as malformed"
);
assert_eq!(admin.buckets_usage[bucket].size, companion_size);
let path = format!(
"{}/{}",
crate::disk::BUCKET_META_PREFIX,
rustfs_data_usage::DATA_USAGE_OBSERVED_OBJECT_NAME
);
let bytes = serde_json::to_vec(&snapshot).expect("encode valid companion snapshot");
crate::config::com::save_config(store, &path, bytes.clone())
.await
.expect("persist companion beside canonical fields");
crate::data_usage::invalidate_data_usage_snapshot_cache().await;
(path, bytes)
}
#[tokio::test(flavor = "current_thread")]
#[serial]
async fn usage_companions_do_not_expand_legacy_fallback_or_durable_admission() {
let mut decisions = Vec::new();
for protocol in [0, 1, 2] {
for (primary, companion_size) in [(true, 0), (true, 1_000_000), (false, 1_000_000)] {
let (dirs, store, sys) = isolated_durable_quota_store().await;
let bucket = format!("usage-companion-quota-{}", Uuid::new_v4().simple());
let quota = match protocol {
0 => legacy_quota_json(4096),
1 => serde_json::to_vec(&BucketQuota::new(Some(4096))).unwrap(),
_ => serde_json::to_vec(&BucketQuota::new_sharded(4096)).unwrap(),
};
create_bucket_with_quota_json(&store, &bucket, quota).await;
let (path, bytes) = persist_companion_fixture(store.clone(), &bucket, primary, companion_size).await;
let checker = if protocol == 0 {
QuotaChecker::new(Arc::new(RwLock::new(BucketMetadataSys::new(store.clone()))))
} else {
QuotaChecker::new(sys)
};
if protocol == 0 {
let small = checker.check_quota(&bucket, QuotaOperation::PutObject, 512).await;
if primary {
let small = small.expect("grounded primary fallback");
assert!(small.allowed && !small.uses_durable_reservations);
assert_eq!(small.current_usage, Some(1000));
assert!(
!checker
.check_quota(&bucket, QuotaOperation::PutObject, 4096)
.await
.expect("legacy limit")
.allowed
);
} else {
assert!(
matches!(small, Err(QuotaError::UsageUnavailable { .. })),
"a companion cannot invent a legacy baseline"
);
}
} else {
assert!(
checker
.check_quota(&bucket, QuotaOperation::PutObject, 512)
.await
.expect("durable checker")
.uses_durable_reservations
);
if protocol == 1 {
assert!(matches!(
store
.put_object(
&bucket,
"bootstrap",
&mut PutObjReader::from_vec(vec![0x5a; 512]),
&ObjectOptions::default()
)
.await,
Err(StorageError::SlowDown)
));
crate::bucket::quota::reservation::retry_quota_reconciliation_for_test(store.clone(), &bucket)
.await
.expect("real v1 ledger bootstrap");
}
store
.put_object(&bucket, "fits", &mut PutObjReader::from_vec(vec![0x5a; 4096]), &ObjectOptions::default())
.await
.expect("ledger admits exactly the physical quota regardless of companion");
assert!(
matches!(
store
.put_object(&bucket, "exceeds", &mut PutObjReader::from_vec(vec![0x5a; 1]), &ObjectOptions::default())
.await,
Err(StorageError::QuotaExceeded { .. })
),
"a low companion cannot expand the ledger"
);
}
assert_eq!(
crate::config::com::read_config(store.clone(), &path)
.await
.expect("retained scanner evidence"),
bytes
);
decisions
.push(serde_json::json!({"protocol": protocol, "primary_baseline": primary, "companion_size": companion_size}));
crate::data_usage::prepare_bucket_usage_for_namespace_change(&bucket, None)
.await
.expect("clear fixture caches");
crate::data_usage::invalidate_data_usage_snapshot_cache().await;
stop_reporting_fixture(&store).await;
let paths = dirs.iter().map(|dir| dir.path().to_path_buf()).collect::<Vec<_>>();
drop(store);
drop(dirs);
assert!(paths.iter().all(|path| !path.exists()));
}
}
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-19", "assertion_id": "USAGE-19-A02", "status": "PASS",
"evidence": {"validated_companion_fixtures": decisions, "legacy_primary_bytes": 1000, "durable_limit_bytes": 4096, "companion_only_legacy_admission": "UsageUnavailable"}
})
);
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-19", "status": "PASS", "fixtures_removed": true})
);
}
@@ -52,9 +52,9 @@ use super::replication_resync_boundary::{
#[cfg(test)]
use super::replication_resync_boundary::{RESYNC_META_FORMAT, RESYNC_META_VERSION, WIRE_ZERO_TIME_UNIX};
use super::replication_storage_boundary::{
AdvancedGetOptions, EcstoreObjectOperations, GetObjectReader, HTTPPreconditions, HTTPRangeSpec, ObjectInfo, ObjectOptions,
ObjectToDelete, ReplicationObjectIO, ReplicationStatusWritebackCondition, ReplicationStatusWritebackMode, ReplicationStorage,
StatObjectOptions, StorageObjectInfoOrErr, WalkOptions,
EcstoreObjectOperations, GetObjectReader, HTTPPreconditions, HTTPRangeSpec, ObjectInfo, ObjectOptions, ObjectToDelete,
ReplicationObjectIO, ReplicationStatusWritebackCondition, ReplicationStatusWritebackMode, ReplicationStorage,
StorageObjectInfoOrErr, WalkOptions,
};
#[cfg(test)]
use super::replication_storage_boundary::{NamespaceLockFence, NamespaceLockSignalTestFence, ReplicationDeletedObject};
@@ -89,9 +89,9 @@ use rmp_serde;
use rustfs_gateway_types::persistence::PersistedReplicationConfiguration;
use rustfs_s3_types::EventName;
use rustfs_utils::http::{
AMZ_OBJECT_LOCK_LEGAL_HOLD, AMZ_OBJECT_LOCK_MODE, AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE, AMZ_TAGGING_DIRECTIVE,
SUFFIX_REPLICATION_RESET, SUFFIX_REPLICATION_STATUS, SUFFIX_REPLICATION_TARGET_VERSION_ARN_PREFIX, has_internal_suffix,
insert_str, replication_target_versions,
AMZ_OBJECT_LOCK_LEGAL_HOLD, AMZ_OBJECT_LOCK_MODE, AMZ_OBJECT_LOCK_RETAIN_UNTIL_DATE, SUFFIX_REPLICATION_RESET,
SUFFIX_REPLICATION_RESET_ARN_PREFIX, SUFFIX_REPLICATION_STATUS, SUFFIX_REPLICATION_TARGET_VERSION_ARN_PREFIX,
has_internal_suffix, insert_str, replication_target_versions,
};
use rustfs_utils::{DEFAULT_SIP_HASH_KEY, get_env_usize, sip_hash};
use std::collections::{HashMap, HashSet};
@@ -4116,6 +4116,17 @@ fn replication_status_writeback_mode(state_update_needed: bool) -> ReplicationSt
}
}
/// Source-object metadata a replication worker publishes with its terminal
/// status.
#[derive(Clone, Copy, Default)]
struct ReplicationStatusWriteback<'a> {
replication_internal: Option<&'a String>,
/// `(arn, version id the target assigned)` for targets minting their own ids.
target_version_ledger: &'a [(String, String)],
/// `(arn, resync stamp)` for targets this attempt resynced.
resync_stamps: &'a [(String, String)],
}
/// Publish a worker's status with a storage-enforced compare-and-set token.
/// `put_object_metadata` checks the token while it owns the object write lock,
/// avoiding both a read/write race and any need to hold a hot object lock
@@ -4123,12 +4134,16 @@ fn replication_status_writeback_mode(state_update_needed: bool) -> ReplicationSt
fn replication_status_writeback_options(
roi: &ReplicateObjectInfo,
replication_lock_guard: &rustfs_lock::NamespaceLockGuard,
new_replication_internal: Option<&String>,
target_version_ledger: &[(String, String)],
writeback: ReplicationStatusWriteback<'_>,
mode: ReplicationStatusWritebackMode,
) -> ObjectOptions {
let ReplicationStatusWriteback {
replication_internal,
target_version_ledger,
resync_stamps,
} = writeback;
let mut eval_metadata = HashMap::new();
if let Some(status) = new_replication_internal {
if let Some(status) = replication_internal {
insert_str(&mut eval_metadata, SUFFIX_REPLICATION_STATUS, status.clone());
}
// One durable key per drifting target: the version id it assigned to this
@@ -4141,6 +4156,12 @@ fn replication_status_writeback_options(
assigned_version_id.clone(),
);
}
// The per-target existing-object resync stamp. Without it the object keeps
// answering "not yet resynced" for the target's reset id, and the scanner
// re-queues it on every cycle.
for (arn, stamp) in resync_stamps {
insert_str(&mut eval_metadata, &format!("{SUFFIX_REPLICATION_RESET_ARN_PREFIX}{arn}"), stamp.clone());
}
let mut write_opts = ObjectOptions {
version_id: roi.version_id.map(|version_id| version_id.to_string()),
eval_metadata: Some(eval_metadata),
@@ -4162,13 +4183,11 @@ async fn persist_replication_state_if_current<S: ReplicationStorage>(
roi: &ReplicateObjectInfo,
storage: &Arc<S>,
replication_lock_guard: &rustfs_lock::NamespaceLockGuard,
new_replication_internal: Option<&String>,
target_version_ledger: &[(String, String)],
writeback: ReplicationStatusWriteback<'_>,
mode: ReplicationStatusWritebackMode,
object_info: &mut ObjectInfo,
) -> Result<ReplicationStatePersistOutcome> {
let write_opts =
replication_status_writeback_options(roi, replication_lock_guard, new_replication_internal, target_version_ledger, mode);
let write_opts = replication_status_writeback_options(roi, replication_lock_guard, writeback, mode);
match storage.put_object_metadata(&roi.bucket, &roi.name, &write_opts).await {
Ok(updated) => {
*object_info = updated;
@@ -4334,6 +4353,12 @@ pub(crate) async fn replicate_object_with_outcome<S: ReplicationStorage>(
.filter(|target| !target.is_empty())
.filter_map(|target| Some((target.arn.clone(), target.target_version_id.clone()?)))
.collect();
let resync_stamps: Vec<(String, String)> = rinfos
.targets
.iter()
.filter(|target| !target.is_empty() && !target.resync_timestamp.is_empty())
.map(|target| (target.arn.clone(), target.resync_timestamp.clone()))
.collect();
let state_update_needed = roi.replication_status_internal != new_replication_internal
|| rinfos.replication_resynced()
|| !target_version_ledger.is_empty();
@@ -4343,8 +4368,11 @@ pub(crate) async fn replicate_object_with_outcome<S: ReplicationStorage>(
&roi,
&storage,
&obj_lock_guard,
new_replication_internal.as_ref(),
&target_version_ledger,
ReplicationStatusWriteback {
replication_internal: new_replication_internal.as_ref(),
target_version_ledger: &target_version_ledger,
resync_stamps: &resync_stamps,
},
writeback_mode,
&mut object_info,
)
@@ -5005,8 +5033,6 @@ impl ReplicateObjectInfoExt for ReplicateObjectInfo {
return rinfo;
}
let _sopts = replicate_all_stat_options(&object_info, &bucket, &tgt_client);
let Some((replication_action, object_info)) = resolve_replicate_all_action(
ReplicateAllActionContext {
siblings: &storage,
@@ -5090,6 +5116,13 @@ impl ReplicateObjectInfoExt for ReplicateObjectInfo {
return rinfo;
}
// The transfer is this target's resync of the object. Stamp it like the
// already-converged outcome above, or the next scanner cycle admits the
// object for the same reset id again.
if self.op_type == ReplicationType::ExistingObject && !tgt_client.reset_id.is_empty() {
apply_replication_resync_timestamp(&mut rinfo, &tgt_client.reset_id);
}
rinfo
}
@@ -5238,34 +5271,6 @@ fn note_replicate_all_target_bucket_empty(bucket: &str, tgt_client: &TargetClien
});
}
/// Build the stat options for the target metadata comparison, logging (without
/// failing) when the tagging directive header cannot be set.
fn replicate_all_stat_options(object_info: &ObjectInfo, bucket: &str, tgt_client: &TargetClient) -> StatObjectOptions {
let mut sopts = StatObjectOptions {
version_id: object_info.version_id.map(|v| v.to_string()).unwrap_or_default(),
internal: AdvancedGetOptions {
replication_proxy_request: "false".to_string(),
..Default::default()
},
..Default::default()
};
if let Err(err) = sopts.set(AMZ_TAGGING_DIRECTIVE, "ACCESS") {
debug!(
event = EVENT_RESYNC_RUNTIME_SKIPPED,
component = LOG_COMPONENT_ECSTORE,
subsystem = LOG_SUBSYSTEM_REPLICATION_RESYNC,
bucket = %bucket,
arn = %tgt_client.arn,
error = %err,
reason = "tagging_directive_header_invalid",
"Skipped replication tagging directive header detail"
);
}
sopts
}
/// Record a failed payload transfer: mark the outcome FAILED, log the target
/// operation failure, and take the target offline when the error is a network
/// failure.
@@ -6395,8 +6400,7 @@ mod tests {
let opts = replication_status_writeback_options(
&ReplicateObjectInfo::default(),
&guard,
None,
&[],
ReplicationStatusWriteback::default(),
ReplicationStatusWritebackMode::ValidateOnly,
);
forced_lost.store(true, std::sync::atomic::Ordering::Release);
@@ -6415,6 +6419,76 @@ mod tests {
);
}
#[tokio::test]
async fn terminal_writeback_persists_resync_stamp_that_ends_existing_object_resync() {
let lock = rustfs_lock::NamespaceLock::new(
"replication-status-writeback-resync-stamp".to_string(),
Arc::new(rustfs_lock::LocalClient::new()),
);
let guard = lock
.get_write_lock(
rustfs_lock::ObjectKey::new("bucket", "/[replicate]/object"),
"worker-a",
std::time::Duration::from_secs(2),
)
.await
.expect("replication lock should be acquired");
let arn = "arn:rustfs:replication::target:bucket";
let reset_before = OffsetDateTime::now_utc();
let mut rinfo = ReplicatedTargetInfo {
arn: arn.to_string(),
replication_status: ReplicationStatusType::Completed,
..Default::default()
};
apply_replication_resync_timestamp(&mut rinfo, "reset-1");
let resync_decision = |user_defined: &HashMap<String, String>, reset_id: &str| {
super::super::replication_object_decision_boundary::resync_target_for_object(
&super::super::replication_object_decision_boundary::ReplicationResyncTargetObject {
mod_time: Some(reset_before - time::Duration::hours(1)),
user_defined,
},
arn,
reset_id,
Some(reset_before),
ReplicationStatusType::Completed,
)
.replicate
};
let persisted = |resync_stamps: &[(String, String)]| {
replication_status_writeback_options(
&ReplicateObjectInfo::default(),
&guard,
ReplicationStatusWriteback {
resync_stamps,
..Default::default()
},
ReplicationStatusWritebackMode::Update,
)
.eval_metadata
.expect("writeback always carries evaluated metadata")
};
let unstamped = persisted(&[]);
assert!(
resync_decision(&unstamped, "reset-1"),
"an object older than the reset date stays admitted until it carries the stamp"
);
let stamped = persisted(&[(rinfo.arn.clone(), rinfo.resync_timestamp.clone())]);
let suffix = format!("{SUFFIX_REPLICATION_RESET_ARN_PREFIX}{arn}");
for prefix in [
rustfs_utils::http::RUSTFS_INTERNAL_PREFIX,
rustfs_utils::http::MINIO_INTERNAL_PREFIX,
] {
assert_eq!(stamped.get(&format!("{prefix}{suffix}")), Some(&rinfo.resync_timestamp));
}
assert!(
!resync_decision(&stamped, "reset-1"),
"the persisted stamp must end the resync for the same reset id"
);
assert!(resync_decision(&stamped, "reset-2"), "a new reset id must admit the object again");
}
#[test]
fn unavailable_object_target_is_persisted_as_failed() {
let arn = "arn:object-target";
@@ -33,7 +33,6 @@ pub(crate) use crate::storage_api_contracts::object::{
};
pub(crate) use crate::storage_api_contracts::range::HTTPRangeSpec;
pub(crate) use rustfs_replication::{DeletedObject as ReplicationDeletedObject, ObjectToDelete as ReplicationObjectToDelete};
pub(crate) use rustfs_s3_client::api_get_options::{AdvancedGetOptions, StatObjectOptions};
type ListObjectsV2Info = StorageListObjectsV2Info<ObjectInfo>;
type ListObjectVersionsInfo = StorageListObjectVersionsInfo<ObjectInfo>;
File diff suppressed because it is too large Load Diff
+458 -22
View File
@@ -60,7 +60,7 @@ use time::OffsetDateTime;
use tracing::{error, info, warn};
use uuid::Uuid;
const SIGNATURE_HEADER: &str = "x-rustfs-signature";
pub(crate) const SIGNATURE_HEADER: &str = "x-rustfs-signature";
pub const RPC_BACKGROUND_ADMISSION_HEADER: &str = "x-rustfs-rpc-background-admission";
const RPC_BACKGROUND_ADMISSION_V1: &str = "v1";
const RPC_BACKGROUND_ADMISSION_DOMAIN: &[u8] = b"rustfs-rpc-background-admission-v1\0";
@@ -78,6 +78,9 @@ pub const RPC_BOOT_EPOCH_CHALLENGE_HEADER: &str = "x-rustfs-rpc-boot-epoch-chall
pub const RPC_BOOT_EPOCH_PROOF_HEADER: &str = "x-rustfs-rpc-boot-epoch-proof";
pub(crate) const RPC_REPLAY_CACHE_CAPABILITY_HEADER: &str = "x-rustfs-rpc-replay-cache-capability";
pub(crate) const RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER: &str = "x-rustfs-rpc-replay-cache-capability-proof";
pub(crate) const RPC_MSGPACK_MANIFEST_CAPABILITY_REQUEST_HEADER: &str = "x-rustfs-rpc-msgpack-manifest-request";
pub(crate) const RPC_MSGPACK_MANIFEST_CAPABILITY_HEADER: &str = "x-rustfs-rpc-msgpack-manifest-capability";
pub(crate) const RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_HEADER: &str = "x-rustfs-rpc-msgpack-manifest-capability-proof";
const RPC_REPLAY_SCOPE_VERSION_V3: &str = "3";
const RPC_RESPONSE_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-response-proof-v1\0";
@@ -124,6 +127,8 @@ const RPC_REPLAY_SCOPE_DOMAIN: &[u8] = b"rustfs-rpc-replay-scope-v3\0";
const RPC_BOOT_EPOCH_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-boot-epoch-proof-v1\0";
const RPC_REPLAY_CACHE_CAPABILITY_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-replay-cache-capability-proof-v1\0";
const RPC_REPLAY_CACHE_CAPABILITY_V1: &str = "dynamic-replay-cache-v1";
const RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_DOMAIN: &[u8] = b"rustfs-rpc-msgpack-manifest-capability-proof-v1\0";
pub(crate) const RPC_MSGPACK_MANIFEST_CAPABILITY_V1: &str = "msgpack-compat-manifest-v1";
const HTTP_PUT_FILE_AUTH_DOMAIN: &[u8] = b"rustfs-http-put-file-auth-v1\0";
const HTTP_PUT_FILE_CAPABILITY_AUTH_DOMAIN: &[u8] = b"rustfs-http-put-file-capability-v1\0";
const UNSIGNED_PAYLOAD: &str = "UNSIGNED-PAYLOAD";
@@ -139,6 +144,8 @@ const REPLAY_CACHE_AUTO_MEMORY_PERCENT: u64 = 13;
const REPLAY_CACHE_METADATA_BYTES: u64 = 1024 * 1024;
const REPLAY_CACHE_TABLE_OVERHEAD_BYTES: u64 = 512;
const NS_SCANNER_CAPABILITY_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-capability-v3";
const NS_SCANNER_COMPLETE_OBSERVATION_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-complete-observation-v1";
const NS_SCANNER_DURABLE_PROGRESS_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-durable-progress-v1";
const NS_SCANNER_CHECKPOINT_COVERAGE_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-checkpoint-coverage-v1";
const NS_SCANNER_TIER_REGISTRY_GENERATION_AUTH_DOMAIN: &[u8] = b"rustfs-ns-scanner-tier-registry-generation-v1";
pub const TONIC_RPC_PREFIX: &str = "/node_service.NodeService";
@@ -795,6 +802,8 @@ fn update_ns_scanner_capability_mac(
server_epoch: Uuid,
supports_tier_registry_generation: bool,
supports_checkpoint_coverage: bool,
supports_durable_progress: bool,
supports_complete_observation: bool,
) {
mac.update(NS_SCANNER_CAPABILITY_AUTH_DOMAIN);
mac.update(&NS_SCANNER_PROTOCOL_VERSION.to_be_bytes());
@@ -809,14 +818,22 @@ fn update_ns_scanner_capability_mac(
if supports_checkpoint_coverage {
mac.update(NS_SCANNER_CHECKPOINT_COVERAGE_AUTH_DOMAIN);
}
if supports_durable_progress {
mac.update(NS_SCANNER_DURABLE_PROGRESS_AUTH_DOMAIN);
}
if supports_complete_observation {
mac.update(NS_SCANNER_COMPLETE_OBSERVATION_AUTH_DOMAIN);
}
}
fn generate_ns_scanner_capability_proof(
fn generate_ns_scanner_capability_proof_with_observation(
secret: &str,
challenge: Uuid,
server_epoch: Uuid,
supports_tier_registry_generation: bool,
supports_checkpoint_coverage: bool,
supports_durable_progress: bool,
supports_complete_observation: bool,
) -> std::io::Result<Vec<u8>> {
if challenge.is_nil() || server_epoch.is_nil() {
return Err(std::io::Error::other("Invalid namespace scanner capability scope"));
@@ -829,17 +846,22 @@ fn generate_ns_scanner_capability_proof(
server_epoch,
supports_tier_registry_generation,
supports_checkpoint_coverage,
supports_durable_progress,
supports_complete_observation,
);
Ok(mac.finalize().into_bytes().to_vec())
}
fn verify_ns_scanner_capability_proof(
#[allow(clippy::too_many_arguments)]
fn verify_ns_scanner_capability_proof_with_observation(
secret: &str,
challenge: Uuid,
server_epoch: Uuid,
proof: &[u8],
supports_tier_registry_generation: bool,
supports_checkpoint_coverage: bool,
supports_durable_progress: bool,
supports_complete_observation: bool,
) -> std::io::Result<()> {
if challenge.is_nil() || server_epoch.is_nil() {
return Err(std::io::Error::other("Invalid namespace scanner capability scope"));
@@ -852,11 +874,35 @@ fn verify_ns_scanner_capability_proof(
server_epoch,
supports_tier_registry_generation,
supports_checkpoint_coverage,
supports_durable_progress,
supports_complete_observation,
);
mac.verify_slice(proof)
.map_err(|_| std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Invalid namespace scanner capability proof"))
}
fn generate_ns_scanner_capability_proof(
secret: &str,
challenge: Uuid,
server_epoch: Uuid,
tier: bool,
checkpoint: bool,
progress: bool,
) -> std::io::Result<Vec<u8>> {
generate_ns_scanner_capability_proof_with_observation(secret, challenge, server_epoch, tier, checkpoint, progress, false)
}
fn verify_ns_scanner_capability_proof(
secret: &str,
challenge: Uuid,
server_epoch: Uuid,
proof: &[u8],
tier: bool,
checkpoint: bool,
progress: bool,
) -> std::io::Result<()> {
verify_ns_scanner_capability_proof_with_observation(secret, challenge, server_epoch, proof, tier, checkpoint, progress, false)
}
pub fn sign_ns_scanner_capability(challenge: Uuid, server_epoch: Uuid) -> std::io::Result<Vec<u8>> {
sign_ns_scanner_capability_with_tier_registry_generation(challenge, server_epoch, false)
}
@@ -878,6 +924,22 @@ pub fn sign_ns_scanner_capability_with_checkpoint_coverage(
server_epoch: Uuid,
supports_tier_registry_generation: bool,
supports_checkpoint_coverage: bool,
) -> std::io::Result<Vec<u8>> {
sign_ns_scanner_capability_with_durable_progress(
challenge,
server_epoch,
supports_tier_registry_generation,
supports_checkpoint_coverage,
false,
)
}
pub fn sign_ns_scanner_capability_with_durable_progress(
challenge: Uuid,
server_epoch: Uuid,
supports_tier_registry_generation: bool,
supports_checkpoint_coverage: bool,
supports_durable_progress: bool,
) -> std::io::Result<Vec<u8>> {
generate_ns_scanner_capability_proof(
&get_shared_secret()?,
@@ -885,6 +947,7 @@ pub fn sign_ns_scanner_capability_with_checkpoint_coverage(
server_epoch,
supports_tier_registry_generation,
supports_checkpoint_coverage,
supports_durable_progress,
)
}
@@ -909,6 +972,24 @@ pub fn verify_ns_scanner_capability_with_checkpoint_coverage(
proof: &[u8],
supports_tier_registry_generation: bool,
supports_checkpoint_coverage: bool,
) -> std::io::Result<()> {
verify_ns_scanner_capability_with_durable_progress(
challenge,
server_epoch,
proof,
supports_tier_registry_generation,
supports_checkpoint_coverage,
false,
)
}
pub fn verify_ns_scanner_capability_with_durable_progress(
challenge: Uuid,
server_epoch: Uuid,
proof: &[u8],
supports_tier_registry_generation: bool,
supports_checkpoint_coverage: bool,
supports_durable_progress: bool,
) -> std::io::Result<()> {
verify_ns_scanner_capability_proof(
&get_shared_secret()?,
@@ -917,6 +998,74 @@ pub fn verify_ns_scanner_capability_with_checkpoint_coverage(
proof,
supports_tier_registry_generation,
supports_checkpoint_coverage,
supports_durable_progress,
)
}
pub fn sign_ns_scanner_capability_with_usage_capabilities(
challenge: Uuid,
server_epoch: Uuid,
tier: bool,
checkpoint: bool,
progress: bool,
observation: bool,
) -> std::io::Result<Vec<u8>> {
generate_ns_scanner_capability_proof_with_observation(
&get_shared_secret()?,
challenge,
server_epoch,
tier,
checkpoint,
progress,
observation,
)
}
fn ns_scanner_usage_watch_capability_mac(secret: &str, challenge: Uuid, server_epoch: Uuid) -> std::io::Result<HmacSha256> {
if challenge.is_nil() || server_epoch.is_nil() {
return Err(std::io::Error::other("Invalid namespace scanner usage watch capability scope"));
}
let mut mac =
<HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
mac.update(b"rustfs-ns-scanner-usage-watch-capability-v1\0");
mac.update(&NS_SCANNER_PROTOCOL_VERSION.to_be_bytes());
mac.update(challenge.as_bytes());
mac.update(server_epoch.as_bytes());
Ok(mac)
}
/// Sign the independent worker capability to validate bucket watches before
/// reusing or durably publishing a complete scanner cache.
pub fn sign_ns_scanner_usage_watch_capability(challenge: Uuid, server_epoch: Uuid) -> std::io::Result<Vec<u8>> {
Ok(ns_scanner_usage_watch_capability_mac(&get_shared_secret()?, challenge, server_epoch)?
.finalize()
.into_bytes()
.to_vec())
}
pub fn verify_ns_scanner_usage_watch_capability(challenge: Uuid, server_epoch: Uuid, proof: &[u8]) -> std::io::Result<()> {
ns_scanner_usage_watch_capability_mac(&get_shared_secret()?, challenge, server_epoch)?
.verify_slice(proof)
.map_err(|_| std::io::Error::other("Invalid namespace scanner usage watch capability proof"))
}
pub fn verify_ns_scanner_capability_with_usage_capabilities(
challenge: Uuid,
server_epoch: Uuid,
proof: &[u8],
tier: bool,
checkpoint: bool,
progress: bool,
observation: bool,
) -> std::io::Result<()> {
verify_ns_scanner_capability_proof_with_observation(
&get_shared_secret()?,
challenge,
server_epoch,
proof,
tier,
checkpoint,
progress,
observation,
)
}
@@ -1094,6 +1243,50 @@ fn verify_replay_cache_capability_proof(
.map_err(|_| std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Invalid RPC replay cache capability proof"))
}
fn update_msgpack_manifest_capability_proof(mac: &mut HmacSha256, audience: &str, challenge: Uuid, boot_epoch: Uuid) {
mac.update(RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_DOMAIN);
for part in [
audience.as_bytes(),
b"|",
challenge.as_bytes(),
b"|",
boot_epoch.as_bytes(),
b"|",
RPC_MSGPACK_MANIFEST_CAPABILITY_V1.as_bytes(),
] {
mac.update(part);
}
}
fn generate_msgpack_manifest_capability_proof(
secret: &str,
audience: &str,
challenge: Uuid,
boot_epoch: Uuid,
) -> std::io::Result<String> {
let mut mac =
<HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
update_msgpack_manifest_capability_proof(&mut mac, audience, challenge, boot_epoch);
Ok(base64_simd::STANDARD.encode_to_string(mac.finalize().into_bytes()))
}
fn verify_msgpack_manifest_capability_proof(
secret: &str,
audience: &str,
challenge: Uuid,
boot_epoch: Uuid,
proof: &str,
) -> std::io::Result<()> {
let proof = base64_simd::STANDARD
.decode_to_vec(proof)
.map_err(|_| std::io::Error::other("Invalid RPC msgpack manifest capability proof"))?;
let mut mac =
<HmacSha256 as KeyInit>::new_from_slice(secret.as_bytes()).map_err(|_| std::io::Error::other("Invalid RPC HMAC key"))?;
update_msgpack_manifest_capability_proof(&mut mac, audience, challenge, boot_epoch);
mac.verify_slice(&proof)
.map_err(|_| std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Invalid RPC msgpack manifest capability proof"))
}
fn non_nil_uuid(value: &str, name: &str) -> std::io::Result<Uuid> {
let value = Uuid::parse_str(value).map_err(|_| std::io::Error::other(format!("Invalid {name}")))?;
(!value.is_nil())
@@ -1193,8 +1386,24 @@ pub fn tonic_boot_epoch_challenge(headers: &HeaderMap) -> std::io::Result<Option
.transpose()
}
/// Whether the request opts into the optional msgpack manifest capability proof.
pub fn tonic_msgpack_manifest_capability_requested(headers: &HeaderMap) -> bool {
headers
.get(RPC_MSGPACK_MANIFEST_CAPABILITY_REQUEST_HEADER)
.is_some_and(|value| value == RPC_MSGPACK_MANIFEST_CAPABILITY_V1)
}
/// Build the authenticated response headers for a client boot-epoch challenge.
pub fn tonic_boot_epoch_response_headers(audience: &str, challenge: Uuid) -> std::io::Result<HeaderMap> {
tonic_boot_epoch_response_headers_with_msgpack_capability(audience, challenge, false)
}
/// Build authenticated boot-epoch headers and, when requested, the msgpack manifest capability.
pub fn tonic_boot_epoch_response_headers_with_msgpack_capability(
audience: &str,
challenge: Uuid,
include_msgpack_manifest: bool,
) -> std::io::Result<HeaderMap> {
let boot_epoch = tonic_rpc_boot_epoch();
let secret = get_shared_secret()?;
let proof = generate_boot_epoch_proof(&secret, audience, challenge, boot_epoch)?;
@@ -1210,6 +1419,17 @@ pub fn tonic_boot_epoch_response_headers(audience: &str, challenge: Uuid) -> std
RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER,
header_value(&capability_proof, RPC_REPLAY_CACHE_CAPABILITY_PROOF_HEADER)?,
);
if include_msgpack_manifest {
let msgpack_capability_proof = generate_msgpack_manifest_capability_proof(&secret, audience, challenge, boot_epoch)?;
headers.insert(
RPC_MSGPACK_MANIFEST_CAPABILITY_HEADER,
HeaderValue::from_static(RPC_MSGPACK_MANIFEST_CAPABILITY_V1),
);
headers.insert(
RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_HEADER,
header_value(&msgpack_capability_proof, RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_HEADER)?,
);
}
Ok(headers)
}
@@ -1243,6 +1463,12 @@ pub(crate) struct AuthenticatedPeerReplayCapabilities {
pub(crate) dynamic_replay_cache: bool,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(crate) struct AuthenticatedPeerMsgpackCapabilities {
pub(crate) boot_epoch: Uuid,
pub(crate) msgpack_compat_manifest: bool,
}
pub(crate) fn verify_tonic_peer_replay_capabilities_response(
audience: &str,
challenge: Uuid,
@@ -1274,6 +1500,57 @@ pub(crate) fn verify_tonic_peer_replay_capabilities_response(
})
}
#[cfg(test)]
pub(crate) fn verify_tonic_peer_msgpack_capabilities_response(
audience: &str,
challenge: Uuid,
headers: &HeaderMap,
) -> std::io::Result<AuthenticatedPeerMsgpackCapabilities> {
let secret = get_shared_secret()?;
let boot_epoch = verify_tonic_boot_epoch_response_with_secret(&secret, audience, challenge, headers)?;
verify_tonic_peer_msgpack_capability_for_epoch_with_secret(&secret, audience, challenge, boot_epoch, headers)
}
pub(crate) fn verify_tonic_peer_msgpack_capability_for_authenticated_epoch(
audience: &str,
challenge: Uuid,
boot_epoch: Uuid,
headers: &HeaderMap,
) -> std::io::Result<AuthenticatedPeerMsgpackCapabilities> {
verify_tonic_peer_msgpack_capability_for_epoch_with_secret(&get_shared_secret()?, audience, challenge, boot_epoch, headers)
}
fn verify_tonic_peer_msgpack_capability_for_epoch_with_secret(
secret: &str,
audience: &str,
challenge: Uuid,
boot_epoch: Uuid,
headers: &HeaderMap,
) -> std::io::Result<AuthenticatedPeerMsgpackCapabilities> {
let capability = headers.get(RPC_MSGPACK_MANIFEST_CAPABILITY_HEADER);
let proof = headers.get(RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_HEADER);
if capability.is_none() && proof.is_none() {
return Ok(AuthenticatedPeerMsgpackCapabilities {
boot_epoch,
msgpack_compat_manifest: false,
});
}
let capability = capability
.and_then(|value| value.to_str().ok())
.ok_or_else(|| std::io::Error::other("Missing RPC msgpack manifest capability"))?;
if capability != RPC_MSGPACK_MANIFEST_CAPABILITY_V1 {
return Err(std::io::Error::other("Unsupported RPC msgpack manifest capability"));
}
let proof = proof
.and_then(|value| value.to_str().ok())
.ok_or_else(|| std::io::Error::other("Missing RPC msgpack manifest capability proof"))?;
verify_msgpack_manifest_capability_proof(secret, audience, challenge, boot_epoch, proof)?;
Ok(AuthenticatedPeerMsgpackCapabilities {
boot_epoch,
msgpack_compat_manifest: true,
})
}
fn valid_content_sha256(value: &str) -> bool {
value == UNSIGNED_PAYLOAD
|| (value.len() == 64
@@ -1309,7 +1586,7 @@ fn tonic_rpc_metric_operation(path: &str) -> &'static str {
Some("ReadMultiple") => INTERNODE_OPERATION_GRPC_READ_MULTIPLE,
Some("ReadVersion") => INTERNODE_OPERATION_GRPC_READ_VERSION,
Some("BatchReadVersion") => INTERNODE_OPERATION_GRPC_BATCH_READ_VERSION,
Some("WriteAll") => INTERNODE_OPERATION_GRPC_WRITE_ALL,
Some("WriteAll" | "WriteFormatControl") => INTERNODE_OPERATION_GRPC_WRITE_ALL,
Some("CompareAndUpdateFile") => INTERNODE_OPERATION_GRPC_COMPARE_AND_UPDATE_FILE,
Some("Lock") => INTERNODE_OPERATION_GRPC_LOCK,
Some("UnLock") => INTERNODE_OPERATION_GRPC_UNLOCK,
@@ -2202,13 +2479,119 @@ mod tests {
let secret = "test-scanner-capability-secret";
let challenge = Uuid::new_v4();
let server_epoch = Uuid::new_v4();
let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false, false)
let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false, false, false)
.expect("capability proof should be generated");
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, false).is_ok());
assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), server_epoch, &proof, false, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, Uuid::new_v4(), &proof, false, false).is_err());
assert!(verify_ns_scanner_capability_proof("different-secret", challenge, server_epoch, &proof, false, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, false, false).is_ok());
assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), server_epoch, &proof, false, false, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, Uuid::new_v4(), &proof, false, false, false).is_err());
assert!(
verify_ns_scanner_capability_proof("different-secret", challenge, server_epoch, &proof, false, false, false).is_err()
);
}
#[test]
fn namespace_scanner_watch_capability_is_independent_and_rejects_replay() {
let _ = rustfs_credentials::set_global_rpc_secret("usage-watch-capability-test-secret".into());
let challenge = Uuid::new_v4();
let epoch = Uuid::new_v4();
let proof = sign_ns_scanner_usage_watch_capability(challenge, epoch).expect("watch capability");
verify_ns_scanner_usage_watch_capability(challenge, epoch, &proof).expect("exact watch capability scope");
assert!(verify_ns_scanner_usage_watch_capability(Uuid::new_v4(), epoch, &proof).is_err());
assert!(verify_ns_scanner_usage_watch_capability(challenge, Uuid::new_v4(), &proof).is_err());
for progress in [false, true] {
for observation in [false, true] {
let other =
sign_ns_scanner_capability_with_usage_capabilities(challenge, epoch, true, true, progress, observation)
.expect("independent older capabilities");
assert!(verify_ns_scanner_usage_watch_capability(challenge, epoch, &other).is_err());
assert!(
verify_ns_scanner_capability_with_usage_capabilities(
challenge,
epoch,
&proof,
true,
true,
progress,
observation
)
.is_err()
);
}
}
}
#[test]
fn namespace_scanner_observation_and_progress_scopes_are_independent() {
let challenge = Uuid::new_v4();
let epoch = Uuid::new_v4();
let secret = "independent-usage-capabilities";
for progress in [false, true] {
for observation in [false, true] {
let proof = generate_ns_scanner_capability_proof_with_observation(
secret,
challenge,
epoch,
true,
true,
progress,
observation,
)
.expect("proof");
assert!(
verify_ns_scanner_capability_proof_with_observation(
secret,
challenge,
epoch,
&proof,
true,
true,
progress,
observation
)
.is_ok()
);
assert!(
verify_ns_scanner_capability_proof_with_observation(
secret,
challenge,
epoch,
&proof,
true,
true,
!progress,
observation
)
.is_err()
);
assert!(
verify_ns_scanner_capability_proof_with_observation(
secret,
challenge,
epoch,
&proof,
true,
true,
progress,
!observation
)
.is_err()
);
}
}
}
#[test]
fn namespace_scanner_capability_proof_binds_durable_progress_independently() {
let challenge = Uuid::new_v4();
let epoch = Uuid::new_v4();
let secret = "durable-progress-test";
for supported in [false, true] {
let proof = generate_ns_scanner_capability_proof(secret, challenge, epoch, true, true, supported).expect("proof");
assert!(verify_ns_scanner_capability_proof(secret, challenge, epoch, &proof, true, true, supported).is_ok());
assert!(verify_ns_scanner_capability_proof(secret, challenge, epoch, &proof, true, true, !supported).is_err());
assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), epoch, &proof, true, true, supported).is_err());
}
}
#[test]
@@ -2216,16 +2599,16 @@ mod tests {
let secret = "checkpoint-capability-test-secret";
let challenge = Uuid::new_v4();
let server_epoch = Uuid::new_v4();
let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, true)
let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, true, false)
.expect("checkpoint capability proof");
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, true).is_ok());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, true).is_err());
let legacy = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, false)
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, true, false).is_ok());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, false, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, true, false).is_err());
let legacy = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, false, false)
.expect("legacy generation capability proof");
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &legacy, true, true).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &[], true, true).is_err());
assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), server_epoch, &proof, true, true).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &legacy, true, true, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &[], true, true, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, Uuid::new_v4(), server_epoch, &proof, true, true, false).is_err());
}
#[test]
@@ -2233,14 +2616,14 @@ mod tests {
let secret = "test-scanner-capability-secret";
let challenge = Uuid::new_v4();
let server_epoch = Uuid::new_v4();
let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, false)
let proof = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, true, false, false)
.expect("generation capability proof should be generated");
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, false).is_ok());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, false).is_err());
let legacy = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false, false)
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, true, false, false).is_ok());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &proof, false, false, false).is_err());
let legacy = generate_ns_scanner_capability_proof(secret, challenge, server_epoch, false, false, false)
.expect("legacy capability proof should be generated");
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &legacy, true, false).is_err());
assert!(verify_ns_scanner_capability_proof(secret, challenge, server_epoch, &legacy, true, false, false).is_err());
}
/// Security regression for GHSA-r5qv-rc46-hv8q (internode RPC fail-closed,
@@ -2897,6 +3280,55 @@ mod tests {
assert!(verify_tonic_peer_replay_capabilities_response("node-a:9000", challenge, &changed_capability).is_err());
}
#[test]
fn msgpack_manifest_capability_is_requested_explicitly_and_proved_for_one_epoch() {
ensure_test_rpc_secret();
let challenge = Uuid::new_v4();
let mut request_headers = HeaderMap::new();
assert!(!tonic_msgpack_manifest_capability_requested(&request_headers));
request_headers.insert(
RPC_MSGPACK_MANIFEST_CAPABILITY_REQUEST_HEADER,
HeaderValue::from_static(RPC_MSGPACK_MANIFEST_CAPABILITY_V1),
);
assert!(tonic_msgpack_manifest_capability_requested(&request_headers));
request_headers.insert(
RPC_MSGPACK_MANIFEST_CAPABILITY_REQUEST_HEADER,
HeaderValue::from_static("msgpack-compat-manifest-v2"),
);
assert!(!tonic_msgpack_manifest_capability_requested(&request_headers));
let legacy_headers = tonic_boot_epoch_response_headers("node-a:9000", challenge).expect("legacy capability headers");
let legacy = verify_tonic_peer_msgpack_capabilities_response("node-a:9000", challenge, &legacy_headers)
.expect("authenticated response without msgpack capability");
assert_eq!(legacy.boot_epoch, tonic_rpc_boot_epoch());
assert!(!legacy.msgpack_compat_manifest);
let headers = tonic_boot_epoch_response_headers_with_msgpack_capability("node-a:9000", challenge, true)
.expect("msgpack capability headers");
let capability = verify_tonic_peer_msgpack_capabilities_response("node-a:9000", challenge, &headers)
.expect("matching msgpack capability proof");
assert_eq!(capability.boot_epoch, tonic_rpc_boot_epoch());
assert!(capability.msgpack_compat_manifest);
assert!(verify_tonic_peer_msgpack_capabilities_response("node-b:9000", challenge, &headers).is_err());
assert!(verify_tonic_peer_msgpack_capabilities_response("node-a:9000", Uuid::new_v4(), &headers).is_err());
let mut changed_capability = headers.clone();
changed_capability.insert(
RPC_MSGPACK_MANIFEST_CAPABILITY_HEADER,
HeaderValue::from_static("msgpack-compat-manifest-v2"),
);
assert!(verify_tonic_peer_msgpack_capabilities_response("node-a:9000", challenge, &changed_capability).is_err());
let mut forged_proof = headers;
forged_proof.insert(RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_HEADER, HeaderValue::from_static("forged"));
assert!(verify_tonic_peer_msgpack_capabilities_response("node-a:9000", challenge, &forged_proof).is_err());
let mut missing_proof = forged_proof.clone();
missing_proof.remove(RPC_MSGPACK_MANIFEST_CAPABILITY_PROOF_HEADER);
assert!(verify_tonic_peer_msgpack_capabilities_response("node-a:9000", challenge, &missing_proof).is_err());
let mut missing_value = forged_proof;
missing_value.remove(RPC_MSGPACK_MANIFEST_CAPABILITY_HEADER);
assert!(verify_tonic_peer_msgpack_capabilities_response("node-a:9000", challenge, &missing_value).is_err());
}
#[test]
fn tonic_rpc_auth_failure_reason_maps_security_relevant_errors() {
for (message, reason) in [
@@ -3195,6 +3627,10 @@ mod tests {
tonic_rpc_metric_operation("/node_service.NodeService/WriteAll"),
INTERNODE_OPERATION_GRPC_WRITE_ALL
);
assert_eq!(
tonic_rpc_metric_operation("/node_service.NodeService/WriteFormatControl"),
INTERNODE_OPERATION_GRPC_WRITE_ALL
);
assert_eq!(
tonic_rpc_metric_operation("/node_service.NodeService/CompareAndUpdateFile"),
INTERNODE_OPERATION_GRPC_COMPARE_AND_UPDATE_FILE
@@ -14,14 +14,16 @@
use crate::cluster::rpc::{
build_auth_headers, build_put_file_auth_trailer, verify_ns_scanner_capability_with_checkpoint_coverage,
verify_ns_scanner_capability_with_tier_registry_generation, verify_put_file_capability,
verify_ns_scanner_capability_with_durable_progress, verify_ns_scanner_capability_with_tier_registry_generation,
verify_ns_scanner_capability_with_usage_capabilities, verify_put_file_capability,
};
use crate::disk::error::{Error, Result};
use crate::disk::{FileReader, FileWriter};
use crate::storage_api_contracts::internode::{
NS_SCANNER_BODY_SHA256_QUERY, NS_SCANNER_CAPABILITY_CHALLENGE_QUERY, NS_SCANNER_CHECKPOINT_COVERAGE_QUERY,
NS_SCANNER_CYCLE_QUERY, NS_SCANNER_LEADER_EPOCH_QUERY, NS_SCANNER_PROTOCOL_VERSION, NS_SCANNER_PROTOCOL_VERSION_QUERY,
NS_SCANNER_REQUEST_ID_QUERY, NS_SCANNER_SERVER_EPOCH_QUERY, NS_SCANNER_SESSION_ID_QUERY, NS_SCANNER_SESSION_SEQUENCE_QUERY,
NS_SCANNER_COMPLETE_OBSERVATION_QUERY, NS_SCANNER_CYCLE_QUERY, NS_SCANNER_DURABLE_PROGRESS_QUERY,
NS_SCANNER_LEADER_EPOCH_QUERY, NS_SCANNER_PROTOCOL_VERSION, NS_SCANNER_PROTOCOL_VERSION_QUERY, NS_SCANNER_REQUEST_ID_QUERY,
NS_SCANNER_SERVER_EPOCH_QUERY, NS_SCANNER_SESSION_ID_QUERY, NS_SCANNER_SESSION_SEQUENCE_QUERY,
NS_SCANNER_TIER_REGISTRY_GENERATION_QUERY, NsScannerCapabilityResponse, PUT_FILE_AUTH_QUERY, PUT_FILE_AUTH_V1,
PUT_FILE_CAPABILITY_CHALLENGE_QUERY, PUT_FILE_CAPABILITY_QUERY, PUT_FILE_CAPABILITY_VERSION, PUT_FILE_NONCE_QUERY,
PUT_FILE_SERVER_EPOCH_QUERY, PutFileCapabilityResponse, WALK_DIR_BODY_SHA256_QUERY, WALK_DIR_STREAM_COMPLETION_QUERY,
@@ -30,8 +32,8 @@ use crate::storage_api_contracts::internode::{
use async_trait::async_trait;
use http::{HeaderMap, HeaderValue, Method, header::CONTENT_TYPE};
use rustfs_config::{
DEFAULT_INTERNODE_DATA_TRANSPORT, ENV_RUSTFS_INTERNODE_DATA_TRANSPORT, INTERNODE_DATA_TRANSPORT_TCP,
KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS,
DEFAULT_INTERNODE_DATA_TRANSPORT, ENV_RUSTFS_INTERNODE_DATA_TRANSPORT, INTERNODE_DATA_TRANSPORT_NIXL,
INTERNODE_DATA_TRANSPORT_TCP, KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS,
};
use rustfs_rio::{
ChunkReaderBox, HttpChunkReader, HttpReader, HttpWriter, HttpWriterMemoryReservation, HttpWriterMemoryReserver,
@@ -63,7 +65,7 @@ const NS_SCANNER_PATH: &str = "/rustfs/rpc/ns_scanner";
const NS_SCANNER_MAX_CAPABILITY_RESPONSE_SIZE: usize = 1024;
const PUT_FILE_MAX_CAPABILITY_RESPONSE_SIZE: usize = 1024;
const PUT_FILE_LEGACY_CAPABILITY_TTL: Duration = Duration::from_secs(30);
const PUT_FILE_V1_CAPABILITY_TTL: Duration = Duration::from_secs(30);
pub(super) const PUT_FILE_V1_CAPABILITY_TTL: Duration = Duration::from_secs(30);
const PUT_FILE_CAPABILITY_PROBE_TIMEOUT: Duration = Duration::from_secs(5);
const CONTENT_TYPE_JSON: &str = "application/json";
const CONTENT_TYPE_MSGPACK: &str = "application/msgpack";
@@ -89,7 +91,7 @@ fn unsupported_transport_message(transport: &str) -> String {
}
#[derive(Debug, Clone, Copy)]
enum PutFileCapabilityState {
pub(super) enum PutFileCapabilityState {
LegacyUntil(Instant),
V1 { server_epoch: Uuid, revalidate_after: Instant },
}
@@ -118,8 +120,8 @@ struct PutFileCapabilityFlight {
}
#[derive(Debug, Default)]
struct PutFileCapabilityCacheState {
cached: Option<PutFileCapabilityState>,
pub(super) struct PutFileCapabilityCacheState {
pub(super) cached: Option<PutFileCapabilityState>,
generation: u64,
in_flight: Option<PutFileCapabilityFlight>,
rejected_server_epoch: Option<Uuid>,
@@ -128,12 +130,12 @@ struct PutFileCapabilityCacheState {
// The registry lock is released before taking an entry lock. Entry guards cover
// only cache transitions, never a probe or await; poll-based writers must be
// able to reject an epoch atomically with those transitions.
type PutFileCapabilityCacheEntry = Arc<parking_lot::RwLock<PutFileCapabilityCacheState>>;
pub(super) type PutFileCapabilityCacheEntry = Arc<parking_lot::RwLock<PutFileCapabilityCacheState>>;
static PUT_FILE_CAPABILITY_CACHE: LazyLock<parking_lot::RwLock<HashMap<String, PutFileCapabilityCacheEntry>>> =
LazyLock::new(|| parking_lot::RwLock::new(HashMap::new()));
fn put_file_capability_cache_entry(endpoint: &str) -> PutFileCapabilityCacheEntry {
pub(super) fn put_file_capability_cache_entry(endpoint: &str) -> PutFileCapabilityCacheEntry {
if let Some(entry) = PUT_FILE_CAPABILITY_CACHE.read().get(endpoint).cloned() {
return entry;
}
@@ -155,7 +157,7 @@ fn fresh_put_file_capability(state: Option<PutFileCapabilityState>, now: Instant
}
}
fn reject_put_file_server_epoch(endpoint: &str, server_epoch: Uuid) {
pub(super) fn reject_put_file_server_epoch(endpoint: &str, server_epoch: Uuid) {
let entry = PUT_FILE_CAPABILITY_CACHE.read().get(endpoint).cloned();
if let Some(entry) = entry {
let mut state = entry.write();
@@ -277,6 +279,9 @@ pub struct NsScannerCapabilityRequest {
pub endpoint: String,
pub supports_tier_registry_generation: bool,
pub supports_checkpoint_coverage: bool,
pub supports_durable_progress: bool,
pub supports_complete_observation: bool,
pub supports_usage_watch: bool,
}
/// Data-plane stream opener used by `RemoteDisk`.
@@ -317,6 +322,9 @@ pub trait InternodeDataTransport: Send + Sync + std::fmt::Debug {
proof: Vec::new(),
supports_tier_registry_generation: None,
supports_checkpoint_coverage: None,
supports_durable_progress: None,
supports_complete_observation: None,
usage_watch_proof: None,
})
}
// Interface facet nobody calls yet: every transport implements both, but no
@@ -411,11 +419,53 @@ impl InternodeDataTransport for TcpHttpInternodeDataTransport {
}
async fn probe_ns_scanner_capability(&self, request: NsScannerCapabilityRequest) -> Result<NsScannerCapabilityResponse> {
let request = if request.supports_usage_watch {
match self.probe_ns_scanner_capability_once(&request).await {
Ok(response) => return Ok(response),
Err(error) if ns_scanner_capability_error_allows_legacy(&error) => NsScannerCapabilityRequest {
supports_usage_watch: false,
..request
},
Err(error) => return Err(error),
}
} else {
request
};
let request = if request.supports_complete_observation {
match self.probe_ns_scanner_capability_once(&request).await {
Ok(response) => return Ok(response),
Err(error) if ns_scanner_capability_error_allows_legacy(&error) => NsScannerCapabilityRequest {
supports_complete_observation: false,
supports_usage_watch: false,
..request
},
Err(error) => return Err(error),
}
} else {
request
};
let request = if request.supports_durable_progress {
match self.probe_ns_scanner_capability_once(&request).await {
Ok(response) => return Ok(response),
Err(error) if ns_scanner_capability_error_allows_legacy(&error) => NsScannerCapabilityRequest {
supports_durable_progress: false,
supports_complete_observation: false,
supports_usage_watch: false,
..request
},
Err(error) => return Err(error),
}
} else {
request
};
let request = if request.supports_checkpoint_coverage {
match self.probe_ns_scanner_capability_once(&request).await {
Ok(response) => return Ok(response),
Err(error) if ns_scanner_capability_error_allows_legacy(&error) => NsScannerCapabilityRequest {
supports_checkpoint_coverage: false,
supports_durable_progress: false,
supports_complete_observation: false,
supports_usage_watch: false,
..request
},
Err(error) => return Err(error),
@@ -435,6 +485,9 @@ impl InternodeDataTransport for TcpHttpInternodeDataTransport {
endpoint: request.endpoint.clone(),
supports_tier_registry_generation: false,
supports_checkpoint_coverage: false,
supports_durable_progress: false,
supports_complete_observation: false,
supports_usage_watch: false,
};
match self.probe_ns_scanner_capability_once(&legacy_request).await {
Ok(mut response) => {
@@ -492,13 +545,62 @@ impl TcpHttpInternodeDataTransport {
if response.version != NS_SCANNER_PROTOCOL_VERSION || response.server_epoch.is_nil() {
return Err(Error::other("incompatible remote namespace scanner capability response"));
}
if let Err(err) = verify_ns_scanner_capability_with_checkpoint_coverage(
if request.supports_usage_watch {
if let Some(proof) = response.usage_watch_proof.as_deref() {
crate::cluster::rpc::verify_ns_scanner_usage_watch_capability(challenge, response.server_epoch, proof)
.map_err(|_| Error::other("remote namespace scanner usage watch capability authentication failed"))?;
}
} else {
response.usage_watch_proof = None;
}
if let Err(err) = verify_ns_scanner_capability_with_usage_capabilities(
challenge,
response.server_epoch,
&response.proof,
request.supports_tier_registry_generation,
request.supports_checkpoint_coverage,
request.supports_durable_progress,
request.supports_complete_observation,
) {
if request.supports_complete_observation
&& verify_ns_scanner_capability_with_durable_progress(
challenge,
response.server_epoch,
&response.proof,
request.supports_tier_registry_generation,
request.supports_checkpoint_coverage,
request.supports_durable_progress,
)
.is_ok()
{
normalize_ns_scanner_capability_response(
&mut response,
request.supports_tier_registry_generation,
request.supports_checkpoint_coverage,
request.supports_durable_progress,
false,
);
return Ok(response);
}
if request.supports_durable_progress
&& verify_ns_scanner_capability_with_checkpoint_coverage(
challenge,
response.server_epoch,
&response.proof,
request.supports_tier_registry_generation,
request.supports_checkpoint_coverage,
)
.is_ok()
{
normalize_ns_scanner_capability_response(
&mut response,
request.supports_tier_registry_generation,
request.supports_checkpoint_coverage,
false,
false,
);
return Ok(response);
}
if request.supports_checkpoint_coverage
&& verify_ns_scanner_capability_with_tier_registry_generation(
challenge,
@@ -508,7 +610,13 @@ impl TcpHttpInternodeDataTransport {
)
.is_ok()
{
normalize_ns_scanner_capability_response(&mut response, request.supports_tier_registry_generation, false);
normalize_ns_scanner_capability_response(
&mut response,
request.supports_tier_registry_generation,
false,
false,
false,
);
return Ok(response);
}
// A permissive older peer can ignore the additive marker and
@@ -518,6 +626,8 @@ impl TcpHttpInternodeDataTransport {
if request.supports_tier_registry_generation && ns_scanner_capability_legacy_proof_is_valid(challenge, &response) {
response.supports_tier_registry_generation = None;
response.supports_checkpoint_coverage = None;
response.supports_durable_progress = None;
response.supports_complete_observation = None;
return Ok(response);
}
return Err(Error::other(format!("remote namespace scanner capability authentication failed: {err}")));
@@ -531,11 +641,13 @@ impl TcpHttpInternodeDataTransport {
&mut response,
request.supports_tier_registry_generation,
request.supports_checkpoint_coverage,
request.supports_durable_progress,
request.supports_complete_observation,
);
Ok(response)
}
async fn put_file_auth_capability(&self, endpoint: &str) -> Result<Option<Uuid>> {
pub(super) async fn put_file_auth_capability(&self, endpoint: &str) -> Result<Option<Uuid>> {
resolve_put_file_auth_capability(endpoint, || async {
tokio::time::timeout(PUT_FILE_CAPABILITY_PROBE_TIMEOUT, self.probe_put_file_auth(endpoint))
.await
@@ -665,7 +777,7 @@ fn verify_put_file_capability_response(challenge: Uuid, body: &[u8]) -> Result<U
Ok(response.server_epoch)
}
fn build_read_file_stream_url(request: &ReadStreamRequest) -> String {
pub(super) fn build_read_file_stream_url(request: &ReadStreamRequest) -> String {
format!(
"{}{}?disk={}&volume={}&path={}&offset={}&length={}",
request.endpoint,
@@ -715,7 +827,7 @@ fn build_put_file_capability_url(endpoint: &str, challenge: Uuid) -> String {
)
}
struct PutFileAuthWriter<W> {
pub(super) struct PutFileAuthWriter<W> {
inner: W,
url: String,
nonce: Uuid,
@@ -728,7 +840,7 @@ struct PutFileAuthWriter<W> {
}
impl<W> PutFileAuthWriter<W> {
fn new(inner: W, url: String, nonce: Uuid, endpoint: String, server_epoch: Uuid) -> Self {
pub(super) fn new(inner: W, url: String, nonce: Uuid, endpoint: String, server_epoch: Uuid) -> Self {
Self {
inner,
url,
@@ -865,9 +977,13 @@ fn normalize_ns_scanner_capability_response(
response: &mut NsScannerCapabilityResponse,
requested_generation_support: bool,
requested_checkpoint_coverage: bool,
requested_durable_progress: bool,
requested_complete_observation: bool,
) {
response.supports_tier_registry_generation = requested_generation_support.then_some(true);
response.supports_checkpoint_coverage = requested_checkpoint_coverage.then_some(true);
response.supports_durable_progress = requested_durable_progress.then_some(true);
response.supports_complete_observation = requested_complete_observation.then_some(true);
}
fn ns_scanner_capability_legacy_proof_is_valid(challenge: Uuid, response: &NsScannerCapabilityResponse) -> bool {
@@ -900,7 +1016,7 @@ fn build_ns_scanner_url(request: &NsScannerStreamRequest) -> String {
fn build_ns_scanner_capability_url(request: &NsScannerCapabilityRequest, challenge: Uuid) -> String {
format!(
"{}{}?{}={}&{}={}{}{}",
"{}{}?{}={}&{}={}{}{}{}{}{}",
request.endpoint,
NS_SCANNER_PATH,
NS_SCANNER_PROTOCOL_VERSION_QUERY,
@@ -916,11 +1032,26 @@ fn build_ns_scanner_capability_url(request: &NsScannerCapabilityRequest, challen
format!("&{}=true", NS_SCANNER_CHECKPOINT_COVERAGE_QUERY)
} else {
String::new()
},
if request.supports_durable_progress {
format!("&{}=true", NS_SCANNER_DURABLE_PROGRESS_QUERY)
} else {
String::new()
},
if request.supports_complete_observation {
format!("&{}=true", NS_SCANNER_COMPLETE_OBSERVATION_QUERY)
} else {
String::new()
},
if request.supports_usage_watch {
"&ns_scanner_usage_watch=true".to_string()
} else {
String::new()
}
)
}
fn json_headers() -> HeaderMap {
pub(super) fn json_headers() -> HeaderMap {
let mut headers = HeaderMap::new();
headers.insert(CONTENT_TYPE, HeaderValue::from_static(CONTENT_TYPE_JSON));
headers
@@ -943,6 +1074,9 @@ fn build_internode_data_transport_result(
{
Ok(Arc::new(TcpHttpInternodeDataTransport))
}
Some(transport) if transport.eq_ignore_ascii_case(INTERNODE_DATA_TRANSPORT_NIXL) => {
Ok(Arc::new(super::nixl_internode::NixlInternodeDataTransport::from_env()))
}
Some(transport) => Err(unsupported_transport_message(transport)),
}
}
@@ -1294,6 +1428,9 @@ mod tests {
endpoint: "http://node1:9000".to_string(),
supports_tier_registry_generation: false,
supports_checkpoint_coverage: false,
supports_durable_progress: false,
supports_complete_observation: false,
supports_usage_watch: false,
})
.await
.expect_err("legacy transport should report namespace scanner as unsupported");
@@ -1320,6 +1457,106 @@ mod tests {
assert!(matches!(open_err, Error::MethodNotAllowed));
}
#[tokio::test]
async fn namespace_scanner_watch_capability_preserves_older_capabilities_and_rejects_stale_proof() {
crate::runtime::sources::ensure_test_rpc_secret();
for peer in ["current", "strict-old", "missing-watch", "stale-watch"] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("watch capability listener");
let address = listener.local_addr().expect("listener address");
let epoch = Uuid::new_v4();
let server = tokio::spawn(async move {
let requests = if peer == "strict-old" { 2 } else { 1 };
for index in 0..requests {
let (mut socket, _) = listener.accept().await.expect("watch capability request");
let mut bytes = Vec::new();
while !bytes.windows(4).any(|window| window == b"\r\n\r\n") {
let mut chunk = [0; 1024];
let read = socket.read(&mut chunk).await.expect("request headers");
assert!(read > 0 && bytes.len() < 16 * 1024);
bytes.extend_from_slice(&chunk[..read]);
}
let headers = std::str::from_utf8(&bytes).expect("HTTP headers");
let target = headers.split_whitespace().nth(1).expect("target");
let url = reqwest::Url::parse(&format!("http://{address}{target}")).expect("request URL");
let query: HashMap<_, _> = url.query_pairs().into_owned().collect();
assert_eq!(query.contains_key("ns_scanner_usage_watch"), index == 0);
assert!(query.contains_key(NS_SCANNER_DURABLE_PROGRESS_QUERY));
assert!(query.contains_key(NS_SCANNER_COMPLETE_OBSERVATION_QUERY));
if peer == "strict-old" && index == 0 {
socket
.write_all(b"HTTP/1.1 400 Bad Request\r\ncontent-length: 0\r\nconnection: close\r\n\r\n")
.await
.expect("old parser rejects only the new field");
continue;
}
let challenge = query[NS_SCANNER_CAPABILITY_CHALLENGE_QUERY].parse().expect("challenge");
let proof = crate::cluster::rpc::sign_ns_scanner_capability_with_usage_capabilities(
challenge, epoch, true, true, true, true,
)
.expect("prior capability proof");
let usage_watch_proof = match peer {
"current" => Some(
crate::cluster::rpc::sign_ns_scanner_usage_watch_capability(challenge, epoch).expect("watch proof"),
),
"stale-watch" => Some(
crate::cluster::rpc::sign_ns_scanner_usage_watch_capability(Uuid::new_v4(), epoch)
.expect("stale watch proof"),
),
_ => None,
};
let body = rmp_serde::to_vec_named(&NsScannerCapabilityResponse {
version: NS_SCANNER_PROTOCOL_VERSION,
server_epoch: epoch,
proof,
supports_tier_registry_generation: Some(true),
supports_checkpoint_coverage: Some(true),
supports_durable_progress: Some(true),
supports_complete_observation: Some(true),
usage_watch_proof,
})
.expect("capability body");
socket
.write_all(
format!("HTTP/1.1 200 OK\r\ncontent-length: {}\r\nconnection: close\r\n\r\n", body.len()).as_bytes(),
)
.await
.expect("response headers");
socket.write_all(&body).await.expect("response body");
}
requests
});
let response = tokio::time::timeout(
Duration::from_secs(10),
TcpHttpInternodeDataTransport.probe_ns_scanner_capability(NsScannerCapabilityRequest {
endpoint: format!("http://{address}"),
supports_tier_registry_generation: true,
supports_checkpoint_coverage: true,
supports_durable_progress: true,
supports_complete_observation: true,
supports_usage_watch: true,
}),
)
.await
.expect("bounded probe");
if peer == "stale-watch" {
assert!(
response
.expect_err("stale response must fail authentication")
.to_string()
.contains("authentication failed")
);
} else {
let response = response.expect("verified capability result");
assert_eq!(response.usage_watch_proof.is_some(), peer == "current");
assert_eq!(response.supports_durable_progress, Some(true));
assert_eq!(response.supports_complete_observation, Some(true));
}
assert_eq!(server.await.expect("capability server"), if peer == "strict-old" { 2 } else { 1 });
}
}
#[tokio::test]
async fn namespace_scanner_checkpoint_capability_authenticates_new_and_legacy_peers() {
crate::runtime::sources::ensure_test_rpc_secret();
@@ -1372,6 +1609,9 @@ mod tests {
supports_tier_registry_generation: Some(true),
// Strip a supported bit, or forge it for an older peer.
supports_checkpoint_coverage: (peer != "current").then_some(true),
supports_durable_progress: None,
supports_complete_observation: None,
usage_watch_proof: None,
})
.expect("capability response");
socket
@@ -1390,6 +1630,9 @@ mod tests {
endpoint: format!("http://{address}"),
supports_tier_registry_generation: true,
supports_checkpoint_coverage: true,
supports_durable_progress: false,
supports_complete_observation: false,
supports_usage_watch: false,
}),
)
.await
@@ -1411,6 +1654,206 @@ mod tests {
}
}
#[tokio::test]
async fn namespace_scanner_durable_progress_capability_authenticates_new_and_legacy_peers() {
crate::runtime::sources::ensure_test_rpc_secret();
for peer in ["current", "strict-old", "permissive-old", "invalid-proof", "missing-proof"] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("capability listener");
let address = listener.local_addr().expect("capability listener address");
let server_epoch = Uuid::new_v4();
let server = tokio::spawn(async move {
let requests = if peer == "strict-old" { 2 } else { 1 };
for index in 0..requests {
let (mut socket, _) = listener.accept().await.expect("capability request");
let mut bytes = Vec::new();
while !bytes.windows(4).any(|window| window == b"\r\n\r\n") {
let mut chunk = [0; 1024];
let read = socket.read(&mut chunk).await.expect("capability headers");
assert!(read > 0 && bytes.len() < 16 * 1024, "bounded complete capability headers");
bytes.extend_from_slice(&chunk[..read]);
}
let request = std::str::from_utf8(&bytes).expect("HTTP headers");
let target = request.split_whitespace().nth(1).expect("HTTP request target");
let url = reqwest::Url::parse(&format!("http://{address}{target}")).expect("capability URL");
let query: HashMap<_, _> = url.query_pairs().into_owned().collect();
assert_eq!(query.get(NS_SCANNER_TIER_REGISTRY_GENERATION_QUERY).map(String::as_str), Some("true"));
assert_eq!(query.contains_key(NS_SCANNER_DURABLE_PROGRESS_QUERY), index == 0);
if peer == "strict-old" && index == 0 {
socket
.write_all(b"HTTP/1.1 400 Bad Request\r\ncontent-length: 0\r\nconnection: close\r\n\r\n")
.await
.expect("legacy parser rejection");
continue;
}
let challenge = query[NS_SCANNER_CAPABILITY_CHALLENGE_QUERY].parse().expect("challenge UUID");
let proof = match peer {
"invalid-proof" => vec![0; 32],
"missing-proof" => Vec::new(),
_ => crate::cluster::rpc::sign_ns_scanner_capability_with_durable_progress(
challenge,
server_epoch,
true,
true,
peer == "current",
)
.expect("server capability proof"),
};
let body = rmp_serde::to_vec_named(&NsScannerCapabilityResponse {
version: NS_SCANNER_PROTOCOL_VERSION,
server_epoch,
proof,
supports_tier_registry_generation: Some(true),
// Strip a supported bit, or forge it for an older peer.
supports_checkpoint_coverage: Some(true),
supports_durable_progress: (peer != "current").then_some(true),
supports_complete_observation: None,
usage_watch_proof: None,
})
.expect("capability response");
socket
.write_all(
format!("HTTP/1.1 200 OK\r\ncontent-length: {}\r\nconnection: close\r\n\r\n", body.len()).as_bytes(),
)
.await
.expect("capability response headers");
socket.write_all(&body).await.expect("capability response body");
}
requests
});
let response = tokio::time::timeout(
Duration::from_secs(10),
TcpHttpInternodeDataTransport.probe_ns_scanner_capability(NsScannerCapabilityRequest {
endpoint: format!("http://{address}"),
supports_tier_registry_generation: true,
supports_checkpoint_coverage: true,
supports_durable_progress: true,
supports_complete_observation: false,
supports_usage_watch: false,
}),
)
.await
.expect("bounded capability probe");
if peer.ends_with("proof") {
assert!(
response
.expect_err("unverified capability must fail closed")
.to_string()
.contains("authentication failed")
);
} else {
let response = response.expect("authenticated capability");
assert_eq!(response.server_epoch, server_epoch);
assert_eq!(response.supports_tier_registry_generation, Some(true));
assert_eq!(response.supports_checkpoint_coverage, Some(true));
assert_eq!(response.supports_durable_progress, (peer == "current").then_some(true));
}
assert_eq!(server.await.expect("capability server"), if peer == "strict-old" { 2 } else { 1 });
}
}
#[tokio::test]
async fn namespace_scanner_complete_observation_capability_authenticates_new_and_legacy_peers() {
crate::runtime::sources::ensure_test_rpc_secret();
for peer in ["current", "strict-old", "permissive-old", "invalid-proof", "missing-proof"] {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("capability listener");
let address = listener.local_addr().expect("capability listener address");
let server_epoch = Uuid::new_v4();
let server = tokio::spawn(async move {
let requests = if peer == "strict-old" { 2 } else { 1 };
for index in 0..requests {
let (mut socket, _) = listener.accept().await.expect("capability request");
let mut bytes = Vec::new();
while !bytes.windows(4).any(|window| window == b"\r\n\r\n") {
let mut chunk = [0; 1024];
let read = socket.read(&mut chunk).await.expect("capability headers");
assert!(read > 0 && bytes.len() < 16 * 1024, "bounded complete capability headers");
bytes.extend_from_slice(&chunk[..read]);
}
let request = std::str::from_utf8(&bytes).expect("HTTP headers");
let target = request.split_whitespace().nth(1).expect("HTTP request target");
let url = reqwest::Url::parse(&format!("http://{address}{target}")).expect("capability URL");
let query: HashMap<_, _> = url.query_pairs().into_owned().collect();
assert_eq!(query.get(NS_SCANNER_TIER_REGISTRY_GENERATION_QUERY).map(String::as_str), Some("true"));
assert_eq!(query.contains_key(NS_SCANNER_COMPLETE_OBSERVATION_QUERY), index == 0);
if peer == "strict-old" && index == 0 {
socket
.write_all(b"HTTP/1.1 400 Bad Request\r\ncontent-length: 0\r\nconnection: close\r\n\r\n")
.await
.expect("legacy parser rejection");
continue;
}
let challenge = query[NS_SCANNER_CAPABILITY_CHALLENGE_QUERY].parse().expect("challenge UUID");
let proof = match peer {
"invalid-proof" => vec![0; 32],
"missing-proof" => Vec::new(),
_ => crate::cluster::rpc::sign_ns_scanner_capability_with_usage_capabilities(
challenge,
server_epoch,
true,
true,
true,
peer == "current",
)
.expect("server capability proof"),
};
let body = rmp_serde::to_vec_named(&NsScannerCapabilityResponse {
version: NS_SCANNER_PROTOCOL_VERSION,
server_epoch,
proof,
supports_tier_registry_generation: Some(true),
// Strip a supported bit, or forge it for an older peer.
supports_checkpoint_coverage: Some(true),
supports_durable_progress: Some(true),
supports_complete_observation: (peer != "current").then_some(true),
usage_watch_proof: None,
})
.expect("capability response");
socket
.write_all(
format!("HTTP/1.1 200 OK\r\ncontent-length: {}\r\nconnection: close\r\n\r\n", body.len()).as_bytes(),
)
.await
.expect("capability response headers");
socket.write_all(&body).await.expect("capability response body");
}
requests
});
let response = tokio::time::timeout(
Duration::from_secs(10),
TcpHttpInternodeDataTransport.probe_ns_scanner_capability(NsScannerCapabilityRequest {
endpoint: format!("http://{address}"),
supports_tier_registry_generation: true,
supports_checkpoint_coverage: true,
supports_durable_progress: true,
supports_complete_observation: true,
supports_usage_watch: false,
}),
)
.await
.expect("bounded capability probe");
if peer.ends_with("proof") {
assert!(
response
.expect_err("unverified capability must fail closed")
.to_string()
.contains("authentication failed")
);
} else {
let response = response.expect("authenticated capability");
assert_eq!(response.server_epoch, server_epoch);
assert_eq!(response.supports_tier_registry_generation, Some(true));
assert_eq!(response.supports_checkpoint_coverage, Some(true));
assert_eq!(response.supports_durable_progress, Some(true));
assert_eq!(response.supports_complete_observation, (peer == "current").then_some(true));
}
assert_eq!(server.await.expect("capability server"), if peer == "strict-old" { 2 } else { 1 });
}
}
#[tokio::test]
async fn walk_dir_restores_explicit_remote_missing_error() {
let _ = rustfs_credentials::set_global_rpc_secret("walk-dir-error-test-secret".to_string());
@@ -2154,6 +2597,9 @@ mod tests {
endpoint: "http://node1:9000".to_string(),
supports_tier_registry_generation: false,
supports_checkpoint_coverage: false,
supports_durable_progress: false,
supports_complete_observation: false,
supports_usage_watch: false,
},
challenge,
);
@@ -2174,6 +2620,9 @@ mod tests {
endpoint: "http://node1:9000".to_string(),
supports_tier_registry_generation: true,
supports_checkpoint_coverage: false,
supports_durable_progress: false,
supports_complete_observation: false,
supports_usage_watch: false,
},
challenge,
);
@@ -2213,13 +2662,16 @@ mod tests {
proof: Vec::new(),
supports_tier_registry_generation: None,
supports_checkpoint_coverage: None,
supports_durable_progress: None,
supports_complete_observation: None,
usage_watch_proof: None,
};
normalize_ns_scanner_capability_response(&mut response, true, true);
normalize_ns_scanner_capability_response(&mut response, true, true, false, false);
assert_eq!(response.supports_tier_registry_generation, Some(true));
response.supports_tier_registry_generation = Some(false);
normalize_ns_scanner_capability_response(&mut response, false, false);
normalize_ns_scanner_capability_response(&mut response, false, false, false, false);
assert_eq!(response.supports_tier_registry_generation, None);
}
@@ -2234,6 +2686,9 @@ mod tests {
.expect("placeholder proof should be generated"),
supports_tier_registry_generation: None,
supports_checkpoint_coverage: None,
supports_durable_progress: None,
supports_complete_observation: None,
usage_watch_proof: None,
};
// A proof bound to a different challenge cannot authorize the legacy
// fallback, even though the response has the expected shape.
@@ -2280,13 +2735,24 @@ mod tests {
fn transport_config_known_backends_are_current_oss_values() {
assert_eq!(
KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS,
&[DEFAULT_INTERNODE_DATA_TRANSPORT, INTERNODE_DATA_TRANSPORT_TCP]
&[
DEFAULT_INTERNODE_DATA_TRANSPORT,
INTERNODE_DATA_TRANSPORT_TCP,
INTERNODE_DATA_TRANSPORT_NIXL
]
);
for configured in KNOWN_INTERNODE_DATA_TRANSPORT_BACKENDS {
let transport = build_internode_data_transport(Some(configured)).unwrap();
// NIXL builds everywhere and serves reads over TCP/HTTP until a node
// installs its receive pool; every other known name is the TCP transport.
let expected = if *configured == INTERNODE_DATA_TRANSPORT_NIXL {
INTERNODE_DATA_TRANSPORT_NIXL
} else {
DEFAULT_INTERNODE_DATA_TRANSPORT
};
assert_eq!(transport.name(), DEFAULT_INTERNODE_DATA_TRANSPORT);
assert_eq!(transport.name(), expected);
}
}
+11 -6
View File
@@ -20,6 +20,7 @@ pub(crate) mod context_propagation;
pub(crate) mod http_auth;
pub(crate) mod internode_data_transport;
mod network_probe;
pub(crate) mod nixl_internode;
pub(crate) mod peer_rest_client;
pub(crate) mod peer_s3_client;
pub(crate) mod remote_disk;
@@ -40,12 +41,16 @@ pub use http_auth::{
gen_tonic_signature_headers, normalize_tonic_rpc_audience, rpc_auth_is_resource_exhausted, rpc_background_admission,
set_tonic_canonical_body_digest, set_tonic_mutation_body_digest, set_tonic_rolling_canonical_body_digest,
set_tonic_rolling_mutation_body_digest, sign_ns_scanner_capability, sign_ns_scanner_capability_with_checkpoint_coverage,
sign_ns_scanner_capability_with_tier_registry_generation, sign_put_file_capability, sign_tonic_rpc_response_proof,
tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers, tonic_rpc_auth_failure_reason, verify_ns_scanner_capability,
verify_ns_scanner_capability_with_checkpoint_coverage, verify_ns_scanner_capability_with_tier_registry_generation,
verify_put_file_auth_trailer, verify_put_file_capability, verify_rpc_signature, verify_tonic_boot_epoch_response,
verify_tonic_canonical_body_digest, verify_tonic_mutation_body_digest, verify_tonic_mutation_body_digest_reject_unsigned,
verify_tonic_rpc_response_proof, verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
sign_ns_scanner_capability_with_durable_progress, sign_ns_scanner_capability_with_tier_registry_generation,
sign_ns_scanner_capability_with_usage_capabilities, sign_ns_scanner_usage_watch_capability, sign_put_file_capability,
sign_tonic_rpc_response_proof, tonic_boot_epoch_challenge, tonic_boot_epoch_response_headers,
tonic_boot_epoch_response_headers_with_msgpack_capability, tonic_msgpack_manifest_capability_requested,
tonic_rpc_auth_failure_reason, verify_ns_scanner_capability, verify_ns_scanner_capability_with_checkpoint_coverage,
verify_ns_scanner_capability_with_durable_progress, verify_ns_scanner_capability_with_tier_registry_generation,
verify_ns_scanner_capability_with_usage_capabilities, verify_ns_scanner_usage_watch_capability, verify_put_file_auth_trailer,
verify_put_file_capability, verify_rpc_signature, verify_tonic_boot_epoch_response, verify_tonic_canonical_body_digest,
verify_tonic_mutation_body_digest, verify_tonic_mutation_body_digest_reject_unsigned, verify_tonic_rpc_response_proof,
verify_tonic_rpc_signature, verify_tonic_rpc_signature_with_bootstrap,
};
#[cfg(test)]
pub(crate) use internode_data_transport::TcpHttpInternodeDataTransport;
@@ -0,0 +1,928 @@
// 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.
//! Internode shard reads whose bytes move over NIXL/UCX.
//!
//! The reading node keeps a pool of receive buffers registered with its NIXL
//! agent. For every chunk of a remote shard stream it sends a signed request
//! over the existing internode HTTP control plane naming the shard range, its
//! agent, one registered buffer and a digest of its agent metadata; the serving
//! node reads the range into its own registered staging memory and writes it
//! into that buffer with a NIXL WRITE, then answers with the byte count. The
//! buffer reaches the decoder as a zero-copy `Bytes`. Several chunk requests
//! run per stream so request latency overlaps the transfers.
//!
//! UCX addresses ports by LID or GID, so this works on InfiniBand rails that
//! have no IP addresses. Writes, walks and any stream whose first chunk cannot
//! be served this way use the TCP/HTTP transport.
//!
//! Buffer safety: the serving node may still write into a buffer whose request
//! was abandoned (a dropped reader, chunks past the end of the file). Such
//! buffers are held for [`ABANDONED_BUFFER_HOLD`] before they return to the
//! pool, which covers the serving node's transfer timeout.
use super::internode_data_transport::{
InternodeDataTransport, InternodeDataTransportCapabilities, NsScannerCapabilityRequest, NsScannerStreamRequest,
ReadStreamRequest, TcpHttpInternodeDataTransport, WalkDirStreamRequest, WriteStreamRequest, build_read_file_stream_url,
json_headers,
};
use crate::cluster::rpc::build_auth_headers;
use crate::disk::error::Result;
use crate::disk::{FileReader, FileWriter};
use crate::storage_api_contracts::internode::NsScannerCapabilityResponse;
use async_trait::async_trait;
use bytes::Bytes;
use futures::future::BoxFuture;
use futures::stream::{FuturesOrdered, Stream};
use http::{HeaderValue, Method};
use rustfs_config::{DEFAULT_RUSTFS_NIXL_INTERNODE_DEPTH, ENV_RUSTFS_NIXL_INTERNODE_DEPTH};
use rustfs_rio::{ChunkReader, ChunkReaderBox};
use std::io;
use std::pin::Pin;
use std::sync::{Arc, OnceLock};
use std::task::{Context, Poll};
use std::time::Duration;
use tokio::io::{AsyncRead, ReadBuf};
use tracing::debug;
use uuid::Uuid;
/// Internode route of a NIXL chunk read.
pub const READ_FILE_NIXL_PATH: &str = "/rustfs/rpc/read_file_nixl";
/// Internode route of a NIXL shard write: the disk's node pulls the named buffers.
pub const WRITE_FILE_NIXL_PATH: &str = "/rustfs/rpc/write_file_nixl";
/// Comma-separated buffers a NIXL shard write pulls, in file order (signed).
pub const NIXL_BUFFERS_QUERY: &str = "nixl_buffers";
/// One-time nonce of a NIXL shard write (signed; recorded to refuse replays).
pub const NIXL_NONCE_QUERY: &str = "nixl_nonce";
/// Buffers a writer fills before it sends a segment; a part's shard file
/// usually fits in one.
const WRITE_SEGMENT_BUFFERS: usize = 4;
/// The route the URL builder emits, replaced by [`READ_FILE_NIXL_PATH`].
const READ_FILE_STREAM_PATH: &str = "/rustfs/rpc/read_file_stream";
/// Query parameters of a NIXL chunk read (signed with the URL).
pub const NIXL_AGENT_QUERY: &str = "nixl_agent";
pub const NIXL_BUFFER_QUERY: &str = "nixl_buffer";
pub const NIXL_METADATA_SHA256_QUERY: &str = "nixl_md";
/// The reader's agent metadata, base64; must hash to the signed digest.
pub const NIXL_METADATA_HEADER: &str = "x-rustfs-nixl-metadata";
/// Bytes the serving node wrote into the buffer; fewer than asked means end of file.
pub const NIXL_BYTES_HEADER: &str = "x-rustfs-nixl-bytes";
/// How long a buffer whose request was abandoned stays out of the pool.
pub const ABANDONED_BUFFER_HOLD: Duration = Duration::from_secs(120);
/// Request timeout when the caller sets no stall timeout.
const DEFAULT_CHUNK_TIMEOUT: Duration = Duration::from_secs(60);
const EVENT_NIXL_INTERNODE_FALLBACK: &str = "nixl_internode_fallback";
const LOG_COMPONENT_INTERNODE: &str = "internode";
const LOG_SUBSYSTEM_NIXL: &str = "nixl";
/// Receive buffers registered with this node's NIXL agent.
pub trait NixlRecvPool: Send + Sync + 'static {
/// This node's agent name.
fn agent_name(&self) -> &str;
/// This node's agent metadata, base64.
fn metadata_base64(&self) -> &str;
/// Lowercase hex SHA-256 of the raw agent metadata.
fn metadata_sha256_hex(&self) -> &str;
/// Size of one receive buffer; one chunk request moves at most this much.
fn chunk_bytes(&self) -> usize;
/// One free buffer, waiting for one when the pool is busy.
fn reserve(&self) -> BoxFuture<'static, io::Result<Box<dyn NixlRecvBuffer>>>;
}
/// One registered buffer, back in the pool when dropped. Reads land in it;
/// writes stage shard bytes in it for the disk's node to pull.
pub trait NixlRecvBuffer: Send + Sync + 'static {
/// `<dram|vram>:<device>:<address>:<length>` as the serving node parses it.
fn descriptor(&self) -> String;
/// The same for the first `len` bytes.
fn descriptor_for(&self, len: usize) -> String;
/// The whole buffer, writable.
fn spare_mut(&mut self) -> &mut [u8];
/// The first `len` bytes as an owned, zero-copy `Bytes`.
fn into_bytes(self: Box<Self>, len: usize) -> io::Result<Bytes>;
}
static RECV_POOL: OnceLock<Arc<dyn NixlRecvPool>> = OnceLock::new();
/// Installs this node's receive pool; only the first installation wins.
pub fn install_nixl_recv_pool(pool: Arc<dyn NixlRecvPool>) -> bool {
RECV_POOL.set(pool).is_ok()
}
fn recv_pool() -> Option<Arc<dyn NixlRecvPool>> {
RECV_POOL.get().cloned()
}
/// Internode transport that reads shard streams over NIXL and delegates
/// everything else to TCP/HTTP.
#[derive(Debug)]
pub struct NixlInternodeDataTransport {
tcp: TcpHttpInternodeDataTransport,
depth: usize,
}
impl NixlInternodeDataTransport {
pub fn from_env() -> Self {
Self {
tcp: TcpHttpInternodeDataTransport,
depth: rustfs_utils::get_env_usize(ENV_RUSTFS_NIXL_INTERNODE_DEPTH, DEFAULT_RUSTFS_NIXL_INTERNODE_DEPTH).clamp(1, 64),
}
}
/// A NIXL chunk reader for `request` with its first chunk already landed,
/// or `None` when this read should use TCP/HTTP.
async fn open_nixl(&self, request: &ReadStreamRequest) -> Option<NixlChunkReader> {
let pool = recv_pool()?;
if request.length == 0 {
// Unbounded reads need the file size; TCP/HTTP streams them.
return None;
}
let mut reader = NixlChunkReader::new(pool, request.clone(), self.depth);
match futures::future::poll_fn(|cx| reader.state_mut().poll_chunk(cx, usize::MAX)).await {
Ok(Some(first)) => {
reader.state_mut().current = first;
Some(reader)
}
Ok(None) => Some(reader),
Err(error) => {
debug!(
event = EVENT_NIXL_INTERNODE_FALLBACK,
component = LOG_COMPONENT_INTERNODE,
subsystem = LOG_SUBSYSTEM_NIXL,
result = "fallback",
endpoint = %request.endpoint,
error = %error,
"nixl internode read fell back to tcp"
);
None
}
}
}
}
#[async_trait]
impl InternodeDataTransport for NixlInternodeDataTransport {
async fn open_read(&self, request: ReadStreamRequest) -> Result<FileReader> {
match self.open_nixl(&request).await {
Some(reader) => Ok(Box::new(reader)),
None => self.tcp.open_read(request).await,
}
}
async fn open_read_fresh(&self, request: ReadStreamRequest) -> Result<FileReader> {
match self.open_nixl(&request).await {
Some(reader) => Ok(Box::new(reader)),
None => self.tcp.open_read_fresh(request).await,
}
}
async fn open_read_chunks(&self, request: ReadStreamRequest) -> Result<Option<ChunkReaderBox>> {
match self.open_nixl(&request).await {
Some(reader) => Ok(Some(Box::new(reader))),
None => self.tcp.open_read_chunks(request).await,
}
}
async fn open_read_chunks_fresh(&self, request: ReadStreamRequest) -> Result<Option<ChunkReaderBox>> {
match self.open_nixl(&request).await {
Some(reader) => Ok(Some(Box::new(reader))),
None => self.tcp.open_read_chunks_fresh(request).await,
}
}
async fn open_write(&self, request: WriteStreamRequest) -> Result<FileWriter> {
match recv_pool() {
Some(pool) => Ok(Box::new(NixlFileWriter::new(pool, request))),
None => self.tcp.open_write(request).await,
}
}
async fn open_walk_dir(&self, request: WalkDirStreamRequest) -> Result<FileReader> {
self.tcp.open_walk_dir(request).await
}
async fn open_ns_scanner(&self, request: NsScannerStreamRequest) -> Result<FileReader> {
self.tcp.open_ns_scanner(request).await
}
async fn probe_ns_scanner(&self, request: NsScannerCapabilityRequest) -> Result<Uuid> {
self.tcp.probe_ns_scanner(request).await
}
async fn probe_ns_scanner_capability(&self, request: NsScannerCapabilityRequest) -> Result<NsScannerCapabilityResponse> {
self.tcp.probe_ns_scanner_capability(request).await
}
fn name(&self) -> &'static str {
"nixl"
}
fn capabilities(&self) -> InternodeDataTransportCapabilities {
InternodeDataTransportCapabilities::tcp_http()
}
}
/// A receive buffer lent to one chunk request. Unless the request completed,
/// dropping it holds the buffer out of the pool for [`ABANDONED_BUFFER_HOLD`]
/// because the serving node may still be writing into it.
struct LentBuffer {
buffer: Option<Box<dyn NixlRecvBuffer>>,
}
impl LentBuffer {
fn complete(mut self, len: usize) -> io::Result<Bytes> {
let buffer = self.buffer.take().expect("buffer present until completion");
buffer.into_bytes(len)
}
/// The peer is done with the buffer: back to the pool now.
fn release(mut self) {
drop(self.buffer.take());
}
}
impl Drop for LentBuffer {
fn drop(&mut self) {
if let Some(buffer) = self.buffer.take() {
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
handle.spawn(async move {
tokio::time::sleep(ABANDONED_BUFFER_HOLD).await;
drop(buffer);
});
}
// No runtime to wait on: never hand the memory back.
Err(_) => std::mem::forget(buffer),
}
}
}
}
/// Fetches one chunk: the requested length and the bytes that landed.
async fn fetch_chunk(pool: Arc<dyn NixlRecvPool>, request: ReadStreamRequest, timeout: Duration) -> io::Result<(usize, Bytes)> {
let buffer = LentBuffer {
buffer: Some(pool.reserve().await?),
};
let descriptor = buffer.buffer.as_ref().map(|buffer| buffer.descriptor()).unwrap_or_default();
let mut url = build_read_file_stream_url(&request).replacen(READ_FILE_STREAM_PATH, READ_FILE_NIXL_PATH, 1);
url.push_str(&format!(
"&{NIXL_AGENT_QUERY}={}&{NIXL_BUFFER_QUERY}={}&{NIXL_METADATA_SHA256_QUERY}={}",
urlencoding::encode(pool.agent_name()),
urlencoding::encode(&descriptor),
pool.metadata_sha256_hex()
));
let mut headers = json_headers();
headers.insert(
NIXL_METADATA_HEADER,
HeaderValue::from_str(pool.metadata_base64())
.map_err(|_| io::Error::other("nixl agent metadata is not a header value"))?,
);
build_auth_headers(&url, &Method::GET, &mut headers)?;
let (status, response_headers, _) = rustfs_rio::internode_http_request(&url, Method::GET, headers, Some(timeout)).await?;
if !status.is_success() {
debug!(
component = LOG_COMPONENT_INTERNODE,
subsystem = LOG_SUBSYSTEM_NIXL,
result = "failed",
status = status.as_u16(),
"nixl internode read refused by peer"
);
return Err(io::Error::other("nixl internode read refused by peer"));
}
let landed = response_headers
.get(NIXL_BYTES_HEADER)
.and_then(|value| value.to_str().ok())
.and_then(|value| value.parse::<usize>().ok())
.ok_or_else(|| io::Error::other("nixl internode read reply lacks the byte count"))?;
if landed > request.length {
return Err(io::Error::other("nixl internode read reports more bytes than requested"));
}
Ok((request.length, buffer.complete(landed)?))
}
type ChunkFuture = BoxFuture<'static, io::Result<(usize, Bytes)>>;
struct ReaderState {
pool: Arc<dyn NixlRecvPool>,
base: ReadStreamRequest,
next: usize,
end: usize,
chunk: usize,
depth: usize,
timeout: Duration,
inflight: FuturesOrdered<ChunkFuture>,
current: Bytes,
done: bool,
}
impl ReaderState {
fn refill(&mut self) {
while !self.done && self.inflight.len() < self.depth && self.next < self.end {
let len = self.chunk.min(self.end - self.next);
let mut request = self.base.clone();
request.offset = self.next;
request.length = len;
self.next += len;
self.inflight
.push_back(Box::pin(fetch_chunk(Arc::clone(&self.pool), request, self.timeout)));
}
}
fn poll_chunk(&mut self, cx: &mut Context<'_>, max: usize) -> Poll<io::Result<Option<Bytes>>> {
loop {
if !self.current.is_empty() {
let take = self.current.len().min(max.max(1));
return Poll::Ready(Ok(Some(self.current.split_to(take))));
}
if self.done {
return Poll::Ready(Ok(None));
}
self.refill();
match Pin::new(&mut self.inflight).poll_next(cx) {
Poll::Ready(Some(Ok((asked, bytes)))) => {
if bytes.len() < asked {
// End of file: later chunks hold nothing; their buffers
// are held back as they are dropped.
self.done = true;
self.inflight = FuturesOrdered::new();
}
if bytes.is_empty() {
self.done = true;
return Poll::Ready(Ok(None));
}
self.current = bytes;
}
Poll::Ready(Some(Err(error))) => {
self.done = true;
self.inflight = FuturesOrdered::new();
return Poll::Ready(Err(error));
}
Poll::Ready(None) => {
self.done = true;
return Poll::Ready(Ok(None));
}
Poll::Pending => return Poll::Pending,
}
}
}
}
/// A remote shard stream read over NIXL in pipelined chunks.
pub struct NixlChunkReader {
// The mutex only makes the reader `Sync`; every access goes through `&mut self`.
state: std::sync::Mutex<ReaderState>,
}
impl NixlChunkReader {
fn new(pool: Arc<dyn NixlRecvPool>, request: ReadStreamRequest, depth: usize) -> Self {
let chunk = pool.chunk_bytes().max(1);
let timeout = request.stall_timeout.unwrap_or(DEFAULT_CHUNK_TIMEOUT);
Self {
state: std::sync::Mutex::new(ReaderState {
next: request.offset,
end: request.offset.saturating_add(request.length),
pool,
base: request,
chunk,
depth,
timeout,
inflight: FuturesOrdered::new(),
current: Bytes::new(),
done: false,
}),
}
}
fn state_mut(&mut self) -> &mut ReaderState {
self.state.get_mut().unwrap_or_else(|poisoned| poisoned.into_inner())
}
}
impl ChunkReader for NixlChunkReader {
fn poll_read_chunk(self: Pin<&mut Self>, cx: &mut Context<'_>, max: usize) -> Poll<io::Result<Option<Bytes>>> {
self.get_mut().state_mut().poll_chunk(cx, max)
}
}
impl AsyncRead for NixlChunkReader {
fn poll_read(self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
if buf.remaining() == 0 {
return Poll::Ready(Ok(()));
}
match self.get_mut().state_mut().poll_chunk(cx, buf.remaining()) {
Poll::Ready(Ok(Some(bytes))) => {
buf.put_slice(&bytes);
Poll::Ready(Ok(()))
}
Poll::Ready(Ok(None)) => Poll::Ready(Ok(())),
Poll::Ready(Err(error)) => Poll::Ready(Err(error)),
Poll::Pending => Poll::Pending,
}
}
}
/// Sends one segment of a shard write: the disk's node pulls `buffers` (in
/// file order) and writes them at the end of the file, creating it unless
/// `append`. The buffers return to the pool only after the node answered.
async fn send_segment(
pool: Arc<dyn NixlRecvPool>,
request: WriteStreamRequest,
buffers: Vec<(LentBuffer, usize)>,
append: bool,
last: bool,
timeout: Duration,
) -> io::Result<()> {
let total: usize = buffers.iter().map(|(_, len)| *len).sum();
let descriptors = buffers
.iter()
.map(|(buffer, len)| {
buffer
.buffer
.as_ref()
.map(|buffer| buffer.descriptor_for(*len))
.unwrap_or_default()
})
.collect::<Vec<_>>()
.join(",");
let url = format!(
"{}{WRITE_FILE_NIXL_PATH}?disk={}&volume={}&path={}&append={append}&size={}&last={last}&{NIXL_NONCE_QUERY}={}&{NIXL_AGENT_QUERY}={}&{NIXL_BUFFERS_QUERY}={}&{NIXL_METADATA_SHA256_QUERY}={}",
request.endpoint,
urlencoding::encode(&request.disk),
urlencoding::encode(&request.volume),
urlencoding::encode(&request.path),
request.size,
Uuid::new_v4(),
urlencoding::encode(pool.agent_name()),
urlencoding::encode(&descriptors),
pool.metadata_sha256_hex()
);
let mut headers = json_headers();
headers.insert(
NIXL_METADATA_HEADER,
HeaderValue::from_str(pool.metadata_base64())
.map_err(|_| io::Error::other("nixl agent metadata is not a header value"))?,
);
build_auth_headers(&url, &Method::PUT, &mut headers)?;
let request_started = rustfs_io_metrics::put_stage_timer();
let (status, response_headers, body) = rustfs_rio::internode_http_request(&url, Method::PUT, headers, Some(timeout)).await?;
rustfs_io_metrics::record_put_object_stage_duration_from("nixl_write_segment_request", request_started);
if !status.is_success() {
debug!(
component = LOG_COMPONENT_INTERNODE,
subsystem = LOG_SUBSYSTEM_NIXL,
result = "failed",
status = status.as_u16(),
body_len = body.len(),
"nixl internode write refused by peer"
);
return Err(io::Error::other("nixl internode write refused by peer"));
}
let written = response_headers
.get(NIXL_BYTES_HEADER)
.and_then(|value| value.to_str().ok())
.and_then(|value| value.parse::<usize>().ok());
if written != Some(total) {
debug!(
component = LOG_COMPONENT_INTERNODE,
subsystem = LOG_SUBSYSTEM_NIXL,
result = "failed",
written = ?written,
total,
"nixl internode write stored a different byte count"
);
return Err(io::Error::other("nixl internode write stored a different byte count"));
}
for (buffer, _) in buffers {
buffer.release();
}
Ok(())
}
type SegmentFuture = BoxFuture<'static, io::Result<()>>;
type ReserveFuture = BoxFuture<'static, io::Result<Box<dyn NixlRecvBuffer>>>;
struct WriterState {
pool: Arc<dyn NixlRecvPool>,
base: WriteStreamRequest,
timeout: Duration,
current: Option<(LentBuffer, usize)>,
filled: Vec<(LentBuffer, usize)>,
reserving: Option<ReserveFuture>,
sending: Option<SegmentFuture>,
segments_sent: usize,
shut_down: bool,
}
impl WriterState {
fn start_segment(&mut self, last: bool) {
let buffers = std::mem::take(&mut self.filled);
let append = self.base.append || self.segments_sent > 0;
self.segments_sent += 1;
self.sending = Some(Box::pin(send_segment(
Arc::clone(&self.pool),
self.base.clone(),
buffers,
append,
last,
self.timeout,
)));
}
fn poll_sending(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
match self.sending.as_mut() {
None => Poll::Ready(Ok(())),
Some(sending) => match sending.as_mut().poll(cx) {
Poll::Pending => Poll::Pending,
Poll::Ready(result) => {
self.sending = None;
Poll::Ready(result)
}
},
}
}
fn poll_write(&mut self, cx: &mut Context<'_>, data: &[u8]) -> Poll<io::Result<usize>> {
if self.shut_down {
return Poll::Ready(Err(io::Error::other("nixl internode writer is shut down")));
}
if data.is_empty() {
return Poll::Ready(Ok(0));
}
if let Err(error) = futures::ready!(self.poll_sending(cx)) {
return Poll::Ready(Err(error));
}
while self.current.is_none() {
let pool = Arc::clone(&self.pool);
let reserving = self.reserving.get_or_insert_with(|| pool.reserve());
match reserving.as_mut().poll(cx) {
Poll::Ready(buffer) => {
self.reserving = None;
self.current = Some((LentBuffer { buffer: Some(buffer?) }, 0));
}
Poll::Pending if !self.filled.is_empty() => {
// Send held buffers before waiting for capacity that their acknowledgement releases.
self.reserving = None;
self.start_segment(false);
futures::ready!(self.poll_sending(cx))?;
}
Poll::Pending => return Poll::Pending,
}
}
let (lent, filled) = self.current.as_mut().expect("buffer reserved above");
let spare = lent.buffer.as_mut().expect("lent buffer present").spare_mut();
let n = data.len().min(spare.len() - *filled);
spare[*filled..*filled + n].copy_from_slice(&data[..n]);
*filled += n;
if *filled == spare.len() {
let full = self.current.take().expect("current buffer");
self.filled.push(full);
if self.filled.len() >= WRITE_SEGMENT_BUFFERS {
self.start_segment(false);
}
}
Poll::Ready(Ok(n))
}
fn poll_shutdown(&mut self, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
if !self.shut_down {
if let Err(error) = futures::ready!(self.poll_sending(cx)) {
return Poll::Ready(Err(error));
}
if let Some((buffer, filled)) = self.current.take() {
if filled > 0 {
self.filled.push((buffer, filled));
} else {
buffer.release();
}
}
self.shut_down = true;
if !self.filled.is_empty() || self.segments_sent == 0 {
// The last segment; with nothing written at all it still creates the file.
self.start_segment(true);
}
}
self.poll_sending(cx)
}
}
/// A remote shard file written through NIXL: bytes are staged in registered
/// buffers and the disk's node pulls them, a segment at a time.
pub struct NixlFileWriter {
// The mutex only makes the writer `Sync`; every access goes through `&mut self`.
state: std::sync::Mutex<WriterState>,
}
impl NixlFileWriter {
fn new(pool: Arc<dyn NixlRecvPool>, request: WriteStreamRequest) -> Self {
Self {
state: std::sync::Mutex::new(WriterState {
pool,
base: request,
timeout: DEFAULT_CHUNK_TIMEOUT,
current: None,
filled: Vec::new(),
reserving: None,
sending: None,
segments_sent: 0,
shut_down: false,
}),
}
}
fn state_mut(&mut self) -> &mut WriterState {
self.state.get_mut().unwrap_or_else(|poisoned| poisoned.into_inner())
}
}
impl tokio::io::AsyncWrite for NixlFileWriter {
fn poll_write(self: Pin<&mut Self>, cx: &mut Context<'_>, data: &[u8]) -> Poll<io::Result<usize>> {
self.get_mut().state_mut().poll_write(cx, data)
}
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
// Bytes stay staged until a segment fills or the writer shuts down; a
// flush only waits for a segment already on its way.
self.get_mut().state_mut().poll_sending(cx)
}
fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
self.get_mut().state_mut().poll_shutdown(cx)
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicUsize, Ordering};
struct CountingBuffer {
released: Arc<AtomicUsize>,
}
impl NixlRecvBuffer for CountingBuffer {
fn descriptor(&self) -> String {
"dram:0:0x1000:16".to_owned()
}
fn descriptor_for(&self, len: usize) -> String {
format!("dram:0:0x1000:{len}")
}
fn spare_mut(&mut self) -> &mut [u8] {
&mut []
}
fn into_bytes(self: Box<Self>, len: usize) -> io::Result<Bytes> {
Ok(Bytes::from(vec![7u8; len]))
}
}
impl Drop for CountingBuffer {
fn drop(&mut self) {
self.released.fetch_add(1, Ordering::SeqCst);
}
}
/// A buffer backed by a plain vector, for the writer's staging logic.
struct VecBuffer(Vec<u8>);
impl NixlRecvBuffer for VecBuffer {
fn descriptor(&self) -> String {
self.descriptor_for(self.0.len())
}
fn descriptor_for(&self, len: usize) -> String {
format!("dram:0:0x2000:{len}")
}
fn spare_mut(&mut self) -> &mut [u8] {
&mut self.0
}
fn into_bytes(self: Box<Self>, len: usize) -> io::Result<Bytes> {
Ok(Bytes::copy_from_slice(&self.0[..len]))
}
}
struct VecPool;
impl NixlRecvPool for VecPool {
fn agent_name(&self) -> &str {
"test-agent"
}
fn metadata_base64(&self) -> &str {
""
}
fn metadata_sha256_hex(&self) -> &str {
""
}
fn chunk_bytes(&self) -> usize {
8
}
fn reserve(&self) -> BoxFuture<'static, io::Result<Box<dyn NixlRecvBuffer>>> {
Box::pin(async { Ok(Box::new(VecBuffer(vec![0; 8])) as Box<dyn NixlRecvBuffer>) })
}
}
#[tokio::test]
async fn the_writer_stages_bytes_in_order_until_a_segment_fills() {
use tokio::io::AsyncWriteExt;
let request = WriteStreamRequest {
endpoint: "http://127.0.0.1:1".to_owned(),
disk: "disk".to_owned(),
volume: "volume".to_owned(),
path: "path".to_owned(),
append: false,
size: 20,
};
let mut writer = NixlFileWriter::new(Arc::new(VecPool), request);
let data: Vec<u8> = (0u8..20).collect();
writer
.write_all(&data)
.await
.expect("staging never sends below a full segment");
let state = writer.state_mut();
assert!(state.sending.is_none(), "two full 8-byte buffers stay below the four-buffer segment");
let staged: Vec<u8> = state
.filled
.iter_mut()
.chain(state.current.iter_mut())
.flat_map(|(lent, len)| lent.buffer.as_mut().expect("buffer").spare_mut()[..*len].to_vec())
.collect();
assert_eq!(staged, data);
assert_eq!(state.filled.len(), 2);
assert_eq!(state.current.as_ref().map(|(_, len)| *len), Some(4));
}
struct LimitedBuffer {
bytes: VecBuffer,
_permit: tokio::sync::OwnedSemaphorePermit,
}
impl NixlRecvBuffer for LimitedBuffer {
fn descriptor(&self) -> String {
self.bytes.descriptor()
}
fn descriptor_for(&self, len: usize) -> String {
self.bytes.descriptor_for(len)
}
fn spare_mut(&mut self) -> &mut [u8] {
self.bytes.spare_mut()
}
fn into_bytes(self: Box<Self>, len: usize) -> io::Result<Bytes> {
Ok(Bytes::copy_from_slice(&self.bytes.0[..len]))
}
}
struct LimitedPool(Arc<tokio::sync::Semaphore>);
impl NixlRecvPool for LimitedPool {
fn agent_name(&self) -> &str {
"test-agent"
}
fn metadata_base64(&self) -> &str {
""
}
fn metadata_sha256_hex(&self) -> &str {
""
}
fn chunk_bytes(&self) -> usize {
8
}
fn reserve(&self) -> ReserveFuture {
let permits = Arc::clone(&self.0);
Box::pin(async move {
let permit = permits.acquire_owned().await.map_err(io::Error::other)?;
Ok(Box::new(LimitedBuffer {
bytes: VecBuffer(vec![0; 8]),
_permit: permit,
}) as Box<dyn NixlRecvBuffer>)
})
}
}
#[tokio::test]
async fn the_writer_sends_staged_bytes_when_the_pool_is_full() {
use tokio::io::{AsyncReadExt, AsyncWriteExt};
crate::runtime::sources::ensure_test_rpc_secret();
for chunks in 1..=3 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("segment listener");
let address = listener.local_addr().expect("segment address");
let server = tokio::spawn(async move {
let mut received = 0;
while received < 40 {
let (mut socket, _) = listener.accept().await.expect("segment connection");
let mut request = Vec::new();
while !request.windows(4).any(|bytes| bytes == b"\r\n\r\n") {
let mut bytes = [0; 1024];
let n = socket.read(&mut bytes).await.expect("segment request");
assert!(n > 0 && request.len() < 16384, "bounded request headers");
request.extend_from_slice(&bytes[..n]);
}
let request = std::str::from_utf8(&request).expect("request text");
let target = request.split_whitespace().nth(1).expect("request target");
let url = url::Url::parse(&format!("http://{address}{target}")).expect("segment URL");
let descriptors = url
.query_pairs()
.find(|(name, _)| name == NIXL_BUFFERS_QUERY)
.expect("buffers")
.1;
let bytes: usize = descriptors
.split(',')
.map(|descriptor| {
descriptor
.rsplit(':')
.next()
.expect("buffer length")
.parse::<usize>()
.expect("numeric length")
})
.sum();
assert!(bytes > 0 && bytes <= chunks * 8);
received += bytes;
let response = format!(
"HTTP/1.1 200 OK\r\ncontent-length: 0\r\nconnection: close\r\nx-rustfs-nixl-bytes: {bytes}\r\n\r\n"
);
socket.write_all(response.as_bytes()).await.expect("segment acknowledgement");
}
received
});
let pool = Arc::new(LimitedPool(Arc::new(tokio::sync::Semaphore::new(chunks))));
let request = WriteStreamRequest {
endpoint: format!("http://{address}"),
disk: "disk".to_owned(),
volume: "volume".to_owned(),
path: "path".to_owned(),
append: false,
size: 40,
};
let mut writer = NixlFileWriter::new(pool.clone(), request);
let result = tokio::time::timeout(Duration::from_secs(5), async {
writer.write_all(&[7; 40]).await?;
writer.shutdown().await
})
.await;
if result.is_err() {
server.abort();
}
result
.expect("a writer must dispatch before exhausting its pool")
.expect("shard write");
assert_eq!(server.await.expect("segment server"), 40);
assert_eq!(pool.0.available_permits(), chunks, "acknowledged buffers return to the pool");
}
}
#[tokio::test(start_paused = true)]
async fn abandoned_buffers_return_only_after_the_hold() {
let released = Arc::new(AtomicUsize::new(0));
let lent = LentBuffer {
buffer: Some(Box::new(CountingBuffer {
released: Arc::clone(&released),
})),
};
drop(lent);
tokio::task::yield_now().await;
assert_eq!(released.load(Ordering::SeqCst), 0, "an abandoned buffer must not return at once");
tokio::time::sleep(ABANDONED_BUFFER_HOLD + Duration::from_secs(1)).await;
tokio::task::yield_now().await;
assert_eq!(released.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn completed_buffers_return_with_their_bytes() {
let released = Arc::new(AtomicUsize::new(0));
let lent = LentBuffer {
buffer: Some(Box::new(CountingBuffer {
released: Arc::clone(&released),
})),
};
let bytes = lent.complete(5).expect("bytes");
assert_eq!(bytes.len(), 5);
assert_eq!(released.load(Ordering::SeqCst), 1);
}
}
@@ -97,6 +97,7 @@ const PEER_REST_RECOVERY_MAX_ATTEMPTS: u32 = 60;
const PEER_REST_RECOVERY_MAX_BACKOFF: Duration = Duration::from_secs(30);
const SCANNER_ACTIVITY_MAX_MESSAGE_SIZE: usize = 1024;
const SCANNER_SCOPED_DIRTY_USAGE_STAGE_TIMEOUT: Duration = Duration::from_secs(5);
const SCANNER_USAGE_WATCH_PEER_CONCURRENCY: usize = 4;
/// Reserve time for the acquire response's network/clock uncertainty. The
/// server owns the real expiry; this local deadline is intentionally earlier
/// so a coordinator never starts a bounded persistence operation at the edge
@@ -298,6 +299,22 @@ fn scanner_scoped_dirty_usage_ack_payload(
Ok(payload)
}
/// Authentication binds a response to the complete current request before any
/// returned watch can be consumed. Semantic validation still rejects a signed
/// response for the wrong producer session, bucket, or token.
fn validate_scanner_usage_watch_response(
request: &rustfs_protos::proto_gen::node_service::ScannerUsageWatchRequest,
response: &rustfs_protos::proto_gen::node_service::ScannerUsageWatchResponse,
) -> Result<()> {
use rustfs_protos::usage_watch::{
canonical_usage_watch_request, canonical_usage_watch_response, validate_usage_watch_response,
};
let canonical = canonical_usage_watch_request(request).map_err(|error| Error::other(error.to_string()))?;
let body = canonical_usage_watch_response(&canonical, response).map_err(|error| Error::other(error.to_string()))?;
verify_tonic_rpc_response_proof(&body, response.response_proof.as_ref())?;
validate_usage_watch_response(request, response).map_err(|error| Error::other(error.to_string()))
}
fn scanner_scoped_dirty_usage_ack_response_matches(
request: &ScannerScopedDirtyUsageAckRequest,
response: &ScannerScopedDirtyUsageAckResponse,
@@ -741,6 +758,9 @@ pub struct PeerRestClient {
topology_member: String,
offline: Arc<AtomicBool>,
recovery_running: Arc<AtomicBool>,
/// All clones used by admission, keepalive and root verification share
/// this peer's bounded sender capacity.
scanner_usage_watch_admission: Arc<tokio::sync::Semaphore>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -900,9 +920,20 @@ impl PeerRestClient {
topology_member,
offline: Arc::new(AtomicBool::new(false)),
recovery_running: Arc::new(AtomicBool::new(false)),
scanner_usage_watch_admission: Arc::new(tokio::sync::Semaphore::new(SCANNER_USAGE_WATCH_PEER_CONCURRENCY)),
}
}
async fn acquire_usage_watch_send_permit(&self) -> Result<tokio::sync::OwnedSemaphorePermit> {
timeout(
SCANNER_SCOPED_DIRTY_USAGE_STAGE_TIMEOUT,
self.scanner_usage_watch_admission.clone().acquire_owned(),
)
.await
.map_err(|_| Error::other("usage watch sender admission timed out"))?
.map_err(|_| Error::other("usage watch sender admission is closed"))
}
fn parse_topology_host(peer_host_port: &str, grid_host: &str) -> Result<XHost> {
let url = url::Url::parse(grid_host).map_err(|_| Error::other("peer grid host is not a valid URL"))?;
if !matches!(url.scheme(), "http" | "https")
@@ -1225,12 +1256,23 @@ impl PeerRestClient {
impl PeerRestClient {
pub async fn local_storage_info(&self) -> Result<rustfs_madmin::StorageInfo> {
self.finalize_result(self.local_storage_info_inner().await).await
self.local_storage_info_with_metrics(true).await
}
async fn local_storage_info_inner(&self) -> Result<rustfs_madmin::StorageInfo> {
/// Collect fresh local inventory from this peer, optionally including disk metrics.
///
/// # Errors
/// Returns the existing transport, control-plane or inventory decoding error.
pub async fn local_storage_info_with_metrics(&self, include_metrics: bool) -> Result<rustfs_madmin::StorageInfo> {
self.finalize_result(self.local_storage_info_inner(include_metrics).await)
.await
}
async fn local_storage_info_inner(&self, include_metrics: bool) -> Result<rustfs_madmin::StorageInfo> {
let mut client = self.get_client().await?;
let request = Request::new(LocalStorageInfoRequest { metrics: true });
let request = Request::new(LocalStorageInfoRequest {
metrics: include_metrics,
});
let response = client.local_storage_info(request).await?.into_inner();
if !response.success {
@@ -1639,6 +1681,51 @@ impl PeerRestClient {
Err(Error::NotImplemented)
}
/// Routes one authorized MRF operation without retrying ambiguous mutations.
/// `None` means the selected node predates this protocol; it is never an empty result.
pub async fn mrf_lifecycle(
&self,
topology: String,
node_id: String,
command: Vec<u8>,
timeout: std::time::Duration,
) -> Result<Option<Vec<u8>>> {
use rustfs_protos::proto_gen::node_service::MrfLifecycleRequest;
use rustfs_protos::{MRF_LIFECYCLE_MAX_COMMAND_BYTES, MRF_LIFECYCLE_MAX_MESSAGE_BYTES, MRF_LIFECYCLE_PROTOCOL_VERSION};
if command.len() > MRF_LIFECYCLE_MAX_COMMAND_BYTES {
return Err(Error::other("MRF command exceeds size limit"));
}
let payload = MrfLifecycleRequest {
protocol_version: MRF_LIFECYCLE_PROTOCOL_VERSION,
topology_fingerprint: topology,
node_id,
command: command.into(),
challenge: Uuid::new_v4().as_bytes().to_vec().into(),
};
let mut request = Request::new(payload.clone());
request.set_timeout(timeout);
set_tonic_mutation_body_digest(&mut request)?;
let mut client = self
.get_client()
.await?
.max_decoding_message_size(MRF_LIFECYCLE_MAX_MESSAGE_BYTES)
.max_encoding_message_size(MRF_LIFECYCLE_MAX_MESSAGE_BYTES);
let response = match client.mrf_lifecycle(request).await {
Ok(response) => response.into_inner(),
// RUSTFS_COMPAT_TODO(backlog-3177): old peers lack MRF management. Remove after every supported peer implements this RPC.
Err(status) if status.code() == tonic::Code::Unimplemented => return Ok(None),
Err(status) => return Err(status.into()),
};
let canonical = rustfs_protos::canonical_mrf_lifecycle_response_body(&payload, &response)
.map_err(|_| Error::other("MRF response is too large to authenticate"))?;
verify_tonic_rpc_response_proof(&canonical, &response.response_proof)
.map_err(|_| Error::other("MRF response authentication failed"))?;
if response.protocol_version != MRF_LIFECYCLE_PROTOCOL_VERSION {
return Err(Error::other("unsupported MRF response protocol"));
}
Ok(Some(response.result.to_vec()))
}
pub async fn background_heal_status(&self) -> Result<Option<Vec<u8>>> {
self.finalize_result(
async {
@@ -2438,6 +2525,129 @@ impl PeerRestClient {
.await
}
/// Independently negotiated bucket watches; an old peer returns an error
/// and callers retain the global-generation fallback for that bucket.
pub async fn scanner_usage_watch(
&self,
owner_id: Uuid,
mut entries: Vec<crate::runtime::usage_watch::ScannerUsageWatchRequest>,
) -> Result<Vec<crate::runtime::usage_watch::ScannerUsageWatchObservation>> {
use crate::runtime::usage_watch::{
SCANNER_USAGE_WATCH_COVERAGE_VERSION, SCANNER_USAGE_WATCH_LEASE_MS, ScannerUsageWatchKnown,
ScannerUsageWatchObservation,
};
use rustfs_protos::proto_gen::node_service::{ScannerUsageWatchEntry, ScannerUsageWatchRequest};
use rustfs_protos::usage_watch::*;
entries.sort_by(|left, right| left.bucket.cmp(&right.bucket));
if owner_id.is_nil() || entries.windows(2).any(|pair| pair[0].bucket == pair[1].bucket) {
return Err(Error::other("usage watch request contains duplicate buckets or an invalid owner"));
}
// Local queue pressure is not a network failure. Keep admission errors
// outside finalize_result so they cannot mark a healthy peer offline.
let _send_permit = self.acquire_usage_watch_send_permit().await?;
self.finalize_result(
async {
let mut client = super::client::scanner_control_time_out_client(
&self.grid_host,
TonicInterceptor::Signature(gen_tonic_signature_interceptor()),
)
.await?;
let mut observations = Vec::with_capacity(entries.len());
for batch in entries.chunks(USAGE_WATCH_MAX_ENTRIES) {
let payload = ScannerUsageWatchRequest {
challenge: Uuid::new_v4().as_bytes().to_vec().into(),
protocol_version: USAGE_WATCH_PROTOCOL_VERSION,
owner_id: owner_id.to_string(),
entries: batch
.iter()
.map(|entry| ScannerUsageWatchEntry {
bucket: entry.bucket.clone(),
bucket_incarnation: entry.bucket_incarnation.as_bytes().to_vec().into(),
watch_id: entry.watch_id.map_or_else(Bytes::new, |id| id.as_bytes().to_vec().into()),
release: entry.release,
session_id: entry.session_id.map_or_else(Bytes::new, |id| id.as_bytes().to_vec().into()),
})
.collect(),
};
let canonical = canonical_usage_watch_request(&payload).map_err(|error| Error::other(error.to_string()))?;
let mut request = Request::new(payload.clone());
set_tonic_canonical_body_digest(&mut request, &canonical)?;
let started = std::time::Instant::now();
let response = timeout(SCANNER_SCOPED_DIRTY_USAGE_STAGE_TIMEOUT, client.scanner_usage_watch(request))
.await
.map_err(|_| Error::other("usage watch request timed out"))??
.into_inner();
let budget_used = u64::try_from(started.elapsed().as_millis())
.unwrap_or(u64::MAX)
.saturating_add(250);
validate_scanner_usage_watch_response(&payload, &response)?;
let session = Uuid::from_slice(response.session_id.as_ref())
.map_err(|_| Error::other("invalid usage watch session"))?;
if response.protocol_version != USAGE_WATCH_PROTOCOL_VERSION
|| response.owner_id != payload.owner_id
|| session.is_nil()
|| response.entries.len() != payload.entries.len()
{
return Err(Error::other("usage watch response does not match request"));
}
for (requested, entry) in batch.iter().zip(response.entries) {
if entry.bucket != requested.bucket {
return Err(Error::other("usage watch response bucket order differs"));
}
let known = if entry.known {
let token = Uuid::from_slice(entry.watch_id.as_ref())
.map_err(|_| Error::other("invalid usage watch token"))?;
if token.is_nil()
|| entry.bucket_incarnation.as_ref() != requested.bucket_incarnation.as_bytes()
|| requested.watch_id.is_some_and(|expected| expected != token)
|| entry.revision == 0
|| entry.revision == u64::MAX
|| entry.inflight == u64::MAX
|| entry.coverage_version != SCANNER_USAGE_WATCH_COVERAGE_VERSION
|| entry.coverage_epoch == 0
|| entry.lease_remaining_ms == 0
|| entry.lease_remaining_ms > SCANNER_USAGE_WATCH_LEASE_MS
{
return Err(Error::other("usage watch response contains an invalid proof"));
}
let lease_remaining_ms = entry.lease_remaining_ms.saturating_sub(budget_used);
(lease_remaining_ms != 0).then_some(ScannerUsageWatchKnown {
owner_id,
session_id: session,
watch_id: token,
bucket_incarnation: requested.bucket_incarnation,
revision: entry.revision,
inflight: entry.inflight,
coverage_version: entry.coverage_version,
coverage_epoch: entry.coverage_epoch,
lease_remaining_ms,
})
} else {
if !entry.watch_id.is_empty()
|| !entry.bucket_incarnation.is_empty()
|| entry.revision != 0
|| entry.inflight != 0
|| entry.coverage_version != 0
|| entry.coverage_epoch != 0
|| entry.lease_remaining_ms != 0
{
return Err(Error::other("Unknown usage watch entry contains proof fields"));
}
None
};
observations.push(ScannerUsageWatchObservation {
bucket: entry.bucket,
known,
});
}
}
Ok(observations)
}
.await,
)
.await
}
pub async fn acknowledge_scanner_scoped_dirty_usage(
&self,
owner_id: String,
@@ -3272,6 +3482,74 @@ mod tests {
)
}
#[tokio::test]
async fn usage_watch_client_clones_share_receiver_sized_send_admission() {
let receiver = Arc::new(tokio::sync::Semaphore::new(4));
let occupied = (0..4)
.map(|_| receiver.clone().try_acquire_owned().expect("four receiver slots"))
.collect::<Vec<_>>();
assert!(receiver.try_acquire().is_err(), "an uncoordinated fifth request is rejected");
drop(occupied);
let client = test_peer_client();
let active = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let peak = Arc::new(std::sync::atomic::AtomicUsize::new(0));
let tasks = (0..12).map(|_| {
// Simulate the shared client's independent admission, keeper and
// publication callers. Each uses the actual production gate.
let client = client.clone();
let receiver = receiver.clone();
let active = active.clone();
let peak = peak.clone();
tokio::spawn(async move {
let _send = client
.acquire_usage_watch_send_permit()
.await
.expect("bounded sender admission");
let _receive = receiver
.try_acquire_owned()
.expect("coexisting client clones must never send more than the receiver's four slots");
let count = active.fetch_add(1, Ordering::AcqRel) + 1;
peak.fetch_max(count, Ordering::AcqRel);
tokio::time::sleep(Duration::from_millis(10)).await;
active.fetch_sub(1, Ordering::AcqRel);
})
});
for result in futures::future::join_all(tasks).await {
result.expect("all queued callers finish");
}
assert_eq!(peak.load(Ordering::Acquire), 4);
assert_eq!(active.load(Ordering::Acquire), 0);
assert_eq!(client.scanner_usage_watch_admission.available_permits(), 4);
assert_eq!(receiver.available_permits(), 4);
}
#[tokio::test(start_paused = true)]
async fn usage_watch_sender_queue_timeout_does_not_mark_the_peer_offline() {
let client = test_peer_client();
let _occupied = client
.scanner_usage_watch_admission
.clone()
.acquire_many_owned(4)
.await
.unwrap();
let result = client
.scanner_usage_watch(
Uuid::from_u128(1),
vec![crate::runtime::usage_watch::ScannerUsageWatchRequest {
bucket: "bucket".into(),
bucket_incarnation: Uuid::from_u128(2),
watch_id: None,
session_id: None,
release: false,
}],
)
.await;
assert!(result.unwrap_err().to_string().contains("sender admission timed out"));
assert!(!client.offline.load(Ordering::Acquire));
assert!(!client.recovery_running.load(Ordering::Acquire));
}
fn decode_test_scanner_activity(response: ScannerActivityResponse) -> Result<ScannerPeerActivity> {
decode_scanner_activity_with_verifier(response, &[9; 16], |_canonical, proof| {
(proof == b"proof")
@@ -4347,6 +4625,112 @@ mod tests {
assert!(!client.offline.load(Ordering::Acquire));
}
#[test]
fn usage_watch_consumer_authenticates_the_current_request_and_rejects_replay() {
use rustfs_protos::proto_gen::node_service::{
ScannerUsageWatchEntry, ScannerUsageWatchRequest, ScannerUsageWatchResponse, ScannerUsageWatchResult,
};
use rustfs_protos::usage_watch::{canonical_usage_watch_request, canonical_usage_watch_response};
runtime_sources::ensure_test_rpc_secret();
let request = ScannerUsageWatchRequest {
challenge: Uuid::new_v4().as_bytes().to_vec().into(),
protocol_version: 1,
owner_id: Uuid::new_v4().to_string(),
entries: vec![ScannerUsageWatchEntry {
bucket: "usage-watch".into(),
bucket_incarnation: Uuid::new_v4().as_bytes().to_vec().into(),
watch_id: Uuid::new_v4().as_bytes().to_vec().into(),
session_id: Uuid::new_v4().as_bytes().to_vec().into(),
release: false,
}],
};
let sign = |request: &ScannerUsageWatchRequest, response: &mut ScannerUsageWatchResponse| {
let canonical = canonical_usage_watch_request(request).expect("valid request to sign");
let body = canonical_usage_watch_response(&canonical, response).expect("bounded canonical watch response");
response.response_proof = crate::cluster::rpc::sign_tonic_rpc_response_proof(&body)
.expect("real response HMAC")
.into();
};
let mut response = ScannerUsageWatchResponse {
protocol_version: 1,
owner_id: request.owner_id.clone(),
session_id: request.entries[0].session_id.clone(),
entries: vec![ScannerUsageWatchResult {
bucket: request.entries[0].bucket.clone(),
known: true,
bucket_incarnation: request.entries[0].bucket_incarnation.clone(),
watch_id: request.entries[0].watch_id.clone(),
revision: 7,
inflight: 0,
coverage_version: 1,
coverage_epoch: 3,
lease_remaining_ms: 60_000,
}],
response_proof: Bytes::new(),
};
sign(&request, &mut response);
validate_scanner_usage_watch_response(&request, &response).expect("current request accepts its signed response");
let mut rejected_replays = 0;
for field in 0..8 {
let mut current = request.clone();
match field {
0 => current.challenge = Uuid::new_v4().as_bytes().to_vec().into(),
1 => current.owner_id = Uuid::new_v4().to_string(),
2 => current.entries[0].bucket.push('x'),
3 => current.entries[0].bucket_incarnation = Uuid::new_v4().as_bytes().to_vec().into(),
4 => current.entries[0].watch_id = Uuid::new_v4().as_bytes().to_vec().into(),
5 => current.entries[0].session_id = Uuid::new_v4().as_bytes().to_vec().into(),
6 => current.entries[0].release = true,
_ => current.protocol_version += 1,
}
assert!(
validate_scanner_usage_watch_response(&current, &response).is_err(),
"a previously signed response must not authorize request mutation {field}"
);
rejected_replays += 1;
}
let mut tampered = response.clone();
tampered.entries[0].revision += 1;
assert!(validate_scanner_usage_watch_response(&request, &tampered).is_err());
let mut unsigned = response.clone();
unsigned.response_proof = Bytes::new();
assert!(validate_scanner_usage_watch_response(&request, &unsigned).is_err());
let mut rejected_signed_mismatches = 0;
for field in 0..5 {
let mut mismatched = response.clone();
match field {
0 => mismatched.owner_id = Uuid::new_v4().to_string(),
1 => mismatched.session_id = Uuid::new_v4().as_bytes().to_vec().into(),
2 => mismatched.entries[0].bucket_incarnation = Uuid::new_v4().as_bytes().to_vec().into(),
3 => mismatched.entries[0].watch_id = Uuid::new_v4().as_bytes().to_vec().into(),
_ => mismatched.entries[0].known = false,
}
sign(&request, &mut mismatched);
assert!(
validate_scanner_usage_watch_response(&request, &mismatched).is_err(),
"an authentic HMAC cannot replace requested watch identity or authorize malformed Unknown: {field}"
);
rejected_signed_mismatches += 1;
}
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-12", "assertion_id": "USAGE-12-A07", "status": "PASS",
"evidence": {"current_response_authenticated": true, "replayed_requests_rejected": rejected_replays,
"signed_identity_mismatches_rejected": rejected_signed_mismatches,
"tampered_response_rejected": true, "missing_hmac_rejected": true}
})
);
drop((request, response, tampered, unsigned));
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-12", "status": "PASS", "scope": "process-local"})
);
}
#[test]
fn heal_control_capability_proof_must_authenticate_exact_ack() {
runtime_sources::ensure_test_rpc_secret();
File diff suppressed because it is too large Load Diff
@@ -29,7 +29,7 @@ use rustfs_protos::proto_gen::node_service::{
LockAcquireStatus, LockReleaseStatus, PingRequest,
};
use rustfs_protos::{
ConnectionEvictionLogLevel, evict_failed_connection_with_log_level, models::PingBodyBuilder,
ChannelRebuildReason, ConnectionEvictionLogLevel, evict_failed_connection_with_reason, models::PingBodyBuilder,
proto_gen::node_service::node_service_client::NodeServiceClient,
};
use std::collections::HashMap;
@@ -498,7 +498,7 @@ impl RemoteClient {
))
}
async fn evict_connection(&self, op: &'static str, reason: &str, resource_summary: &str) {
async fn evict_connection(&self, op: &'static str, reason: &str, resource_summary: &str, trigger: EvictionTrigger) {
let log_level = if Self::is_scanner_leader_lock(resource_summary) {
debug!(
addr = %self.addr,
@@ -518,7 +518,11 @@ impl RemoteClient {
);
ConnectionEvictionLogLevel::Warn
};
evict_failed_connection_with_log_level(&self.addr, log_level).await;
let rebuild_reason = match trigger {
EvictionTrigger::Timeout => ChannelRebuildReason::LockTimeout,
EvictionTrigger::Transport => ChannelRebuildReason::LockTransport,
};
evict_failed_connection_with_reason(&self.addr, rebuild_reason, log_level).await;
}
fn summarize_resources(requests: &[LockRequest]) -> String {
@@ -772,7 +776,7 @@ impl RemoteClient {
});
if verdict == EvictionVerdict::Evict {
rustfs_io_metrics::lock_metrics::record_remote_lock_channel_eviction(&self.addr, trigger.as_str());
self.evict_connection(op, reason, resource_summary).await;
self.evict_connection(op, reason, resource_summary, trigger).await;
return;
}
rustfs_io_metrics::lock_metrics::record_remote_lock_channel_eviction_suppressed(&self.addr, verdict.as_str());
+10
View File
@@ -314,6 +314,16 @@ mod tests {
assert_eq!(scanner_kvs.get(SCANNER_DELAY), "");
assert_eq!(scanner_kvs.get(SCANNER_MAX_WAIT), "");
assert_eq!(scanner_kvs.get(SCANNER_CYCLE_MAX_OBJECTS), "0");
for key in [
rustfs_config::SCANNER_BUCKET_QUANTUM_DURATION,
rustfs_config::SCANNER_BUCKET_QUANTUM_OBJECTS,
rustfs_config::SCANNER_BUCKET_QUANTUM_DIRECTORIES,
rustfs_config::SCANNER_BUCKET_QUANTUM_ENTRIES,
rustfs_config::SCANNER_BUCKET_QUANTUM_NAME_BYTES,
] {
assert!(rustfs_config::SCANNER_KEYS.contains(&key), "admin key {key} is registered");
assert_eq!(scanner_kvs.get(key), "0", "quantum dimension {key} stays disabled until rollout");
}
let heal_kvs = cfg
.get_value(HEAL_SUB_SYS, DEFAULT_DELIMITER)
+31
View File
@@ -25,6 +25,12 @@ use rustfs_config::{
SCANNER_MAX_CONCURRENT_SET_SCANS, SCANNER_MAX_WAIT, SCANNER_RECOVERY_BACKOFF_CAP, SCANNER_SPEED, SCANNER_START_DELAY,
SCANNER_WALKERS_PER_DISK, SCANNER_YIELD_EVERY_N_OBJECTS,
};
use rustfs_config::{
DEFAULT_SCANNER_BUCKET_QUANTUM_DIRECTORIES, DEFAULT_SCANNER_BUCKET_QUANTUM_DURATION_SECS,
DEFAULT_SCANNER_BUCKET_QUANTUM_ENTRIES, DEFAULT_SCANNER_BUCKET_QUANTUM_NAME_BYTES, DEFAULT_SCANNER_BUCKET_QUANTUM_OBJECTS,
SCANNER_BUCKET_QUANTUM_DIRECTORIES, SCANNER_BUCKET_QUANTUM_DURATION, SCANNER_BUCKET_QUANTUM_ENTRIES,
SCANNER_BUCKET_QUANTUM_NAME_BYTES, SCANNER_BUCKET_QUANTUM_OBJECTS,
};
use std::sync::LazyLock;
pub static DEFAULT_KVS: LazyLock<KVS> = LazyLock::new(|| {
@@ -69,6 +75,31 @@ pub static DEFAULT_KVS: LazyLock<KVS> = LazyLock::new(|| {
value: DEFAULT_SCANNER_CYCLE_MAX_DIRECTORIES.to_string(),
hidden_if_empty: false,
},
KV {
key: SCANNER_BUCKET_QUANTUM_DURATION.to_owned(),
value: DEFAULT_SCANNER_BUCKET_QUANTUM_DURATION_SECS.to_string(),
hidden_if_empty: false,
},
KV {
key: SCANNER_BUCKET_QUANTUM_OBJECTS.to_owned(),
value: DEFAULT_SCANNER_BUCKET_QUANTUM_OBJECTS.to_string(),
hidden_if_empty: false,
},
KV {
key: SCANNER_BUCKET_QUANTUM_DIRECTORIES.to_owned(),
value: DEFAULT_SCANNER_BUCKET_QUANTUM_DIRECTORIES.to_string(),
hidden_if_empty: false,
},
KV {
key: SCANNER_BUCKET_QUANTUM_ENTRIES.to_owned(),
value: DEFAULT_SCANNER_BUCKET_QUANTUM_ENTRIES.to_string(),
hidden_if_empty: false,
},
KV {
key: SCANNER_BUCKET_QUANTUM_NAME_BYTES.to_owned(),
value: DEFAULT_SCANNER_BUCKET_QUANTUM_NAME_BYTES.to_string(),
hidden_if_empty: false,
},
KV {
key: SCANNER_BITROT_CYCLE.to_owned(),
value: DEFAULT_SCANNER_BITROT_CYCLE_SECS.to_string(),
+37 -7
View File
@@ -6400,7 +6400,7 @@ pub(crate) struct PoolMetaWriteState {
pool_meta_absent: bool,
bootstrap_authority: PoolMetaBootstrapAuthority,
/// First-hand bootstrap authority this process holds for each pool
/// (index = pool index): `Fresh` only for pools it formatted itself,
/// (index = pool index): `Fresh` for pools it formatted or resumed from a complete durable plan,
/// `LegacyAdoption` only for pools whose migration it verified. Empty when
/// the caller tracks deployment-wide authority only.
pool_bootstrap_authorities: Vec<PoolMetaBootstrapAuthority>,
@@ -6478,8 +6478,7 @@ impl PoolMetaWriteState {
}
/// Startup state for a process that loaded every pool format itself and
/// remembers, per pool, whether it created (or adopted) that pool
/// first-hand. Deployment-wide authority is the conjunction across pools:
/// remembers, per pool, whether it created, durably resumed, or adopted that pool. Deployment-wide authority is the conjunction across pools:
/// any pool this process merely read yields `None`, exactly as before.
pub(crate) fn for_startup_with_pool_bootstrap_authorities(
cluster_id: uuid::Uuid,
@@ -6510,7 +6509,7 @@ impl PoolMetaWriteState {
.is_some_and(|authority| authority.is_proven())
}
/// Pools this process formatted or adopted first-hand during this startup.
/// Pools this process formatted, durably resumed, or adopted during startup.
pub(crate) fn attested_pool_indices(&self) -> Vec<usize> {
self.pool_bootstrap_authorities
.iter()
@@ -6527,7 +6526,7 @@ impl PoolMetaWriteState {
/// [`PoolMetaIdentityWriteScope::Pools`]), so a complete, agreeing pending
/// set proves that every pool joined this bootstrap fresh. A missing,
/// corrupt, or disagreeing replica keeps the writer fail-closed, and a
/// restart without first-hand proof never reopens bootstrap on its own.
/// restart requires a complete durable format plan to recover creator proof.
fn pending_identity_attested_by_every_pool(&self) -> bool {
self.elected_bootstrap_writer == Some(true)
&& self.pool_bootstrap_authority_proven(0)
@@ -6759,6 +6758,27 @@ impl PoolMetaWriteState {
self.expected_cluster_id.is_some() && (self.identity_needs_repair || self.identity_initialized != Some(true))
}
/// A committed predecessor authorizes repairing an established identity
/// before the next metadata write. A pending fresh identity must remain
/// pending until its initial metadata commit is recoverable.
pub(crate) fn startup_identity_precedes_metadata_write(&self) -> bool {
!self.pool_meta_absent && !self.identity_is_pending()
}
pub(crate) fn ensure_startup_identity_initialized(&self) -> Result<()> {
if self.expected_cluster_id.is_none()
|| (self.identity_initialized == Some(true)
&& !self.identity_needs_repair
&& !self.identity_replicas_missing
&& !self.identity_replicas_invalid)
{
return Ok(());
}
Err(Error::other(
"pool metadata bootstrap pending: waiting for the elected writer to initialize the identity on every pool",
))
}
pub(crate) fn ensure_write_safe(&self, operation: &str) -> Result<()> {
let (Some(mut context), _) = self.write_block() else {
return Ok(());
@@ -10146,6 +10166,8 @@ impl PoolMeta {
self.save_for_startup_observing(pools, &mut write_state).await.map(|_| ())
}
/// Commits a complete startup snapshot while leaving identity finalization
/// to the caller, after durable format-bootstrap authority is retired.
pub(crate) async fn save_for_startup_observing<S>(
&self,
pools: Vec<Arc<S>>,
@@ -10160,6 +10182,8 @@ impl PoolMeta {
Ok(outcome.into_committed())
}
/// Commits a complete startup snapshot under the writer fence. The caller
/// retires format-bootstrap authority before finalizing initialized identity.
pub(crate) async fn save_for_startup_guarded<S>(
&self,
pools: Vec<Arc<S>>,
@@ -10362,7 +10386,10 @@ impl PoolMeta {
selection.revision.epoch, identity.epoch
)));
}
if !selection.absent && write_state.identity_requires_repair() {
// Full-snapshot saves belong to startup. Their caller retires
// durable format authority before publishing initialized identity.
// Runtime scoped saves retain their existing identity repair.
if indices.is_some() && !selection.absent && write_state.identity_requires_repair() {
let initialized = write_state.identity_initialized != Some(false) || selection.revision.is_generation_protocol();
persist_pool_meta_identity(
pools.clone(),
@@ -10640,7 +10667,10 @@ impl PoolMeta {
confirmed
};
if confirmed.revision == revision && confirmed.canonical.as_ref() == Some(&durable) {
persist_pool_meta_identity(pools, write_state, true, PoolMetaIdentityWriteScope::All, fence, transaction_arm).await?;
if indices.is_some() {
persist_pool_meta_identity(pools, write_state, true, PoolMetaIdentityWriteScope::All, fence, transaction_arm)
.await?;
}
#[cfg(feature = "e2e-test-hooks")]
startup_cas_test_observe(serde_json::json!({
"kind": "confirmed", "object": POOL_META_NAME,
+3 -3
View File
@@ -477,18 +477,18 @@ impl Sets {
}
}
pub(crate) async fn local_storage_info_snapshot(&self) -> rustfs_madmin::StorageInfo {
pub(crate) async fn local_storage_info_snapshot(&self, include_metrics: bool) -> rustfs_madmin::StorageInfo {
let mut futures = Vec::with_capacity(self.disk_set.len());
for set in self.disk_set.iter() {
futures.push(set.local_storage_info_snapshot())
futures.push(set.local_storage_info_snapshot(include_metrics))
}
let results = join_all(futures).await;
let mut disks = Vec::new();
for res in results.into_iter() {
disks.extend_from_slice(&res.disks);
disks.extend(res.disks);
}
rustfs_madmin::StorageInfo {
+74 -8
View File
@@ -56,6 +56,8 @@ pub const DATA_USAGE_ROOT: &str = SLASH_SEPARATOR;
const DATA_COMPRESSION_TOTAL_NAME: &str = ".compression.json";
pub const DATA_USAGE_CACHE_NAME: &str = ".usage-cache.bin";
const DATA_USAGE_CACHE_TTL_SECS: u64 = 30;
const ADMIN_USAGE_INCARNATION_CONCURRENCY: usize = 4;
const ADMIN_USAGE_INCARNATION_TIMEOUT: Duration = Duration::from_secs(2);
// A scanner save invalidates only the saving process's snapshot cache; every
// other node sees it only after reloading. A fail-closed usage lookup for a
// bucket the cached snapshot does not mention at all may reload a copy this
@@ -505,6 +507,7 @@ fn stale_data_usage_persist_reason_for_source(
/// Store data usage info to backend storage
#[instrument(skip(store))]
pub async fn store_data_usage_in_backend(data_usage_info: DataUsageInfo, store: Arc<ECStore>) -> Result<(), Error> {
reject_admin_usage_projection(&data_usage_info)?;
if data_usage_info.usage_snapshot_converged == Some(false) {
return Err(Error::other(
"nonconverged data usage observations cannot replace the quota-authoritative snapshot",
@@ -534,6 +537,7 @@ async fn save_data_usage_in_backend(
store: Arc<ECStore>,
expected_publication_epoch: u64,
) -> Result<(), Error> {
reject_admin_usage_projection(&data_usage_info)?;
let data =
serde_json::to_vec(&data_usage_info).map_err(|e| Error::other(format!("Failed to serialize data usage info: {e}")))?;
@@ -663,8 +667,9 @@ fn remove_bucket_usage_from_info(data_usage_info: &mut DataUsageInfo, bucket: &s
let removed_usage = data_usage_info.buckets_usage.remove(bucket).is_some();
let removed_size = data_usage_info.bucket_sizes.remove(bucket).is_some();
let removed_observation = data_usage_info.usage_snapshot_bucket_observations.remove(bucket).is_some();
if !removed_usage && !removed_size {
if !removed_usage && !removed_size && !removed_observation {
return false;
}
@@ -816,7 +821,9 @@ fn map_data_usage_metadata_read_error(err: Error, object: &str) -> Error {
}
fn data_usage_contains_bucket(data_usage_info: &DataUsageInfo, bucket: &str) -> bool {
data_usage_info.buckets_usage.contains_key(bucket) || data_usage_info.bucket_sizes.contains_key(bucket)
data_usage_info.buckets_usage.contains_key(bucket)
|| data_usage_info.bucket_sizes.contains_key(bucket)
|| data_usage_info.usage_snapshot_bucket_observations.contains_key(bucket)
}
fn advance_data_usage_last_update(data_usage_info: &mut DataUsageInfo) {
@@ -1137,14 +1144,26 @@ fn record_usage_snapshot_decode_failure(operation: &'static str, object: &str, e
}
fn parse_usage_snapshot(buf: &[u8]) -> Result<DataUsageInfo, Error> {
serde_json::from_slice(buf).map_err(|e| {
let mut info: DataUsageInfo = serde_json::from_slice(buf).map_err(|e| {
Error::other(format!(
"Failed to deserialize data usage info: {:?} at line {} column {}",
e.classify(),
e.line(),
e.column()
))
})
})?;
reject_admin_usage_projection(&info)?;
for usage in info.buckets_usage.values_mut() {
usage.normalize_usage_provenance();
}
Ok(info)
}
fn reject_admin_usage_projection(info: &DataUsageInfo) -> Result<(), Error> {
if info.usage_snapshot_admin_projection {
return Err(Error::other("admin usage projections cannot be persisted or used as a storage baseline"));
}
Ok(())
}
/// Decide which usage snapshot to serve: a primary usage object or its
@@ -1327,6 +1346,9 @@ async fn load_data_usage_from_backend_with_baseline(store: Arc<ECStore>) -> Resu
/// Fill quota-baseline gaps from an observed (nonconverged) snapshot without
/// overriding any bucket the authoritative baseline already covers.
fn backfill_degraded_baseline_from_observed(degraded_baseline: &mut HashMap<String, u64>, observed: &DataUsageInfo) {
if observed.usage_snapshot_admin_projection {
return;
}
for (bucket, usage) in &observed.buckets_usage {
degraded_baseline.entry(bucket.clone()).or_insert(usage.size);
}
@@ -1419,6 +1441,7 @@ fn merge_partial_observation_for_admin(mut authoritative: DataUsageInfo, observe
authoritative.usage_snapshot_converged = Some(false);
authoritative.usage_snapshot_authoritative_baseline = observed.usage_snapshot_authoritative_baseline;
authoritative.usage_snapshot_set_states = observed.usage_snapshot_set_states;
authoritative.usage_snapshot_bucket_observations = observed.usage_snapshot_bucket_observations;
authoritative.usage_snapshot_bootstrap_pending = false;
authoritative.buckets_count = authoritative.buckets_usage.len() as u64;
authoritative.bucket_sizes = authoritative
@@ -1437,10 +1460,48 @@ async fn load_admin_data_usage_from_backend(store: Arc<ECStore>) -> Result<DataU
let (authoritative, source) = load_data_usage_snapshot(store.clone()).await?;
// For the one-shot admin view a failed observed read degrades to "no
// observation", same as before the read was fallible.
let observed = load_observed_data_usage_snapshot(store).await.ok().flatten();
let observed = load_observed_data_usage_snapshot(store.clone()).await.ok().flatten();
let (selected, selected_is_current_format) =
select_admin_data_usage_snapshot(authoritative, source.is_authoritative(), observed);
Ok(normalize_loaded_data_usage(selected, selected_is_current_format).await.0)
let mut response = normalize_loaded_data_usage(selected, selected_is_current_format).await.0;
use futures::StreamExt as _;
let deadline = tokio::time::Instant::now() + ADMIN_USAGE_INCARNATION_TIMEOUT;
let mut incarnations = HashMap::new();
{
// Display-only identity reads must not serialize every bucket behind a
// slow metadata lock while holding the shared admin refresh permit.
// The common deadline bounds their total added latency; dropping this
// stream cancels all unfinished reads without spawning detached work.
// Own the names and store across awaits so this future remains Send
// when composed into spawned metrics collectors.
let buckets = response
.usage_snapshot_bucket_observations
.keys()
.cloned()
.collect::<Vec<_>>();
let mut identities = futures::stream::iter(buckets)
.map(move |bucket| {
let store = store.clone();
async move {
let identity = store.bucket_incarnation_id_from_disk(&bucket).await;
(bucket, identity)
}
})
.buffer_unordered(ADMIN_USAGE_INCARNATION_CONCURRENCY);
while tokio::time::Instant::now() < deadline {
let Ok(Some((bucket, identity))) = tokio::time::timeout_at(deadline, identities.next()).await else {
break;
};
// Unavailable, timed-out or recreated buckets retain canonical values.
if let Ok(incarnation) = identity
&& !incarnation.is_nil()
{
incarnations.insert(bucket, incarnation.to_string());
}
}
}
response.project_bucket_observations_for_admin(&incarnations);
Ok(response)
}
fn discard_incomplete_bucket_usage(data_usage_info: &mut DataUsageInfo) {
@@ -2082,7 +2143,9 @@ where
fn apply_live_bucket_usage_to_response(data_usage_info: &mut DataUsageInfo, bucket: &str, usage: &BucketUsageInfo) {
let inserted_bucket = !data_usage_info.buckets_usage.contains_key(bucket);
data_usage_info.bucket_sizes.insert(bucket.to_string(), usage.size);
data_usage_info.buckets_usage.insert(bucket.to_string(), usage.clone());
let mut observed = usage.clone();
observed.mark_observed();
data_usage_info.buckets_usage.insert(bucket.to_string(), observed);
if inserted_bucket {
data_usage_info.usage_snapshot_complete = false;
}
@@ -2774,7 +2837,9 @@ async fn apply_bucket_usage_memory_overlay_if_authoritative(data_usage_info: &mu
}
added_bucket |= !data_usage_info.buckets_usage.contains_key(bucket);
data_usage_info.buckets_usage.insert(bucket.clone(), cached.usage.clone());
let mut observed = cached.usage.clone();
observed.mark_observed();
data_usage_info.buckets_usage.insert(bucket.clone(), observed);
data_usage_info.bucket_sizes.insert(bucket.clone(), cached.usage.size);
changed = true;
}
@@ -3024,6 +3089,7 @@ pub async fn init_compression_total_memory_from_backend(store: Arc<ECStore>) {
#[cfg(test)]
mod tests {
mod companion_projection;
mod snapshot_projection;
use super::*;
@@ -0,0 +1,310 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
use rustfs_data_usage::{
BucketUsageCertification, BucketUsageValueState, DATA_USAGE_BUCKET_OBSERVATION_VERSION, DataUsageBucketObservation,
DataUsageBucketObservationSource, DataUsageSnapshotSetState,
};
mod native_compatibility;
fn companion_snapshot(bucket: &str, incarnation: uuid::Uuid) -> DataUsageInfo {
let completed_at = SystemTime::UNIX_EPOCH + Duration::from_secs(40);
let mut snapshot = data_usage_info_for_test(bucket, 10, 100, completed_at + Duration::from_secs(10));
snapshot.scanner_epoch = Some(2);
snapshot.scanner_cycle = Some(9);
snapshot.usage_snapshot_converged = Some(false);
snapshot.usage_snapshot_pending_buckets = vec![bucket.to_string()];
snapshot.usage_snapshot_pending_bucket_count = 1;
let canonical = snapshot.buckets_usage.get_mut(bucket).expect("canonical bucket");
canonical.bucket_incarnation = Some(incarnation.to_string());
canonical.certify(BucketUsageCertification {
epoch: 2,
cycle: 3,
certified_at: SystemTime::UNIX_EPOCH + Duration::from_secs(30),
});
canonical.mark_carried();
snapshot.usage_snapshot_set_states = vec![DataUsageSnapshotSetState {
pool_index: 0,
set_index: 0,
scanner_epoch: Some(2),
scanner_cycle: Some(9),
scan_plan_digest: Some([1; 32]),
complete: true,
..Default::default()
}];
let mut observed = BucketUsageInfo {
size: 250,
objects_count: 25,
versions_count: 25,
bucket_incarnation: Some(incarnation.to_string()),
..Default::default()
};
observed.mark_observed();
snapshot.usage_snapshot_bucket_observations.insert(
bucket.to_string(),
DataUsageBucketObservation {
version: DATA_USAGE_BUCKET_OBSERVATION_VERSION,
usage: observed,
snapshot_identity: snapshot.snapshot_identity(),
completed_at,
sources: vec![DataUsageBucketObservationSource {
pool_index: 0,
set_index: 0,
bucket_incarnation: incarnation.to_string(),
scanner_epoch: 2,
scanner_cycle: 4,
scan_plan_digest: [1; 32],
started_plan: [2; 32],
requested_plan: [3; 32],
completed_at,
}],
},
);
snapshot
}
#[test]
fn companion_cannot_backfill_quota_and_projection_is_rejected_at_storage_boundaries() {
let incarnation = uuid::Uuid::from_u128(31);
let mut snapshot = companion_snapshot("bucket", incarnation);
let mut canonical_quota = HashMap::new();
backfill_degraded_baseline_from_observed(&mut canonical_quota, &snapshot);
assert_eq!(canonical_quota.get("bucket"), Some(&100), "quota reads only the unchanged main map");
assert_eq!(
snapshot.project_bucket_observations_for_admin(&HashMap::from([("bucket".to_string(), incarnation.to_string())])),
1
);
let mut accidental_quota = HashMap::new();
backfill_degraded_baseline_from_observed(&mut accidental_quota, &snapshot);
assert!(accidental_quota.is_empty());
assert!(reject_admin_usage_projection(&snapshot).is_err());
assert!(certified_bucket_usage(&snapshot, "bucket", incarnation).is_none());
let wire = serde_json::to_vec(&snapshot).expect("admin response remains serializable");
assert!(parse_usage_snapshot(&wire).is_err(), "a serialized response is not a persisted snapshot");
}
#[test]
fn companion_only_observed_snapshot_does_not_create_a_legacy_quota_baseline() {
let incarnation = uuid::Uuid::from_u128(31);
let mut snapshot = companion_snapshot("bucket", incarnation);
snapshot.buckets_usage.clear();
snapshot.bucket_sizes.clear();
snapshot.buckets_count = 0;
snapshot.calculate_totals();
snapshot.usage_snapshot_complete = false;
snapshot.usage_snapshot_partial = true;
snapshot.usage_snapshot_observational = true;
snapshot.usage_snapshot_set_states[0].complete = false;
let decoded = parse_usage_snapshot(&serde_json::to_vec(&snapshot).expect("encode companion-only snapshot"))
.expect("read valid partial snapshot");
assert!(decoded.is_valid_partial_snapshot());
let mut baseline = HashMap::new();
backfill_degraded_baseline_from_observed(&mut baseline, &decoded);
assert!(baseline.is_empty(), "unknown usage must not become either zero or mixed quota usage");
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-08", "assertion_id": "USAGE-08-A02", "status": "PASS",
"evidence": {"primary_buckets": decoded.buckets_usage.len(), "legacy_bucket_sizes": decoded.bucket_sizes.len(), "quota_baseline_buckets": baseline.len(), "companion_buckets": decoded.usage_snapshot_bucket_observations.len(), "partial": decoded.is_valid_partial_snapshot()}
})
);
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-08", "status": "PASS", "scope": "process-local"})
);
}
#[test]
fn bucket_removal_discards_companions_even_without_a_canonical_entry() {
let mut snapshot = companion_snapshot("bucket", uuid::Uuid::from_u128(31));
snapshot.buckets_usage.clear();
snapshot.bucket_sizes.clear();
assert!(data_usage_contains_bucket(&snapshot, "bucket"));
assert!(remove_bucket_usage_from_info(&mut snapshot, "bucket"));
assert!(!data_usage_contains_bucket(&snapshot, "bucket"));
assert!(snapshot.usage_snapshot_bucket_observations.is_empty());
}
#[test]
fn partial_selection_replaces_value_provenance_together() {
let incarnation = uuid::Uuid::from_u128(31);
let authoritative = companion_snapshot("bucket", incarnation);
let mut observed = authoritative.clone();
observed.usage_snapshot_authoritative_baseline = Some(authoritative.snapshot_identity());
observed.scanner_cycle = Some(10);
observed.last_update = Some(SystemTime::UNIX_EPOCH + Duration::from_secs(60));
observed.usage_snapshot_complete = false;
observed.usage_snapshot_partial = true;
observed.usage_snapshot_observational = true;
observed.usage_snapshot_bucket_observations.clear();
let usage = observed.buckets_usage.get_mut("bucket").expect("observed main bucket");
usage.size = 175;
usage.mark_observed();
let (selected, _) = select_admin_data_usage_snapshot(authoritative, true, Some(observed));
assert_eq!(selected.buckets_usage["bucket"].size, 175);
assert_eq!(selected.buckets_usage["bucket"].usage_value_state, Some(BucketUsageValueState::Observed));
assert_eq!(selected.buckets_usage["bucket"].usage_certification, None);
assert!(
selected.usage_snapshot_bucket_observations.is_empty(),
"old root companions cannot cross a baseline change"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[serial]
async fn companion_admin_cache_isolated_from_quota_memory_and_persistence() {
use crate::bucket::metadata_sys::{init_bucket_metadata_sys, test_support::isolated_store_over_temp_disks};
use crate::config::com::save_config;
use crate::storage_api_contracts::bucket::MakeBucketOptions;
let (_dirs, store) = isolated_store_over_temp_disks().await;
init_bucket_metadata_sys(store.clone(), Vec::new()).await;
let bucket = "usage-companion";
store
.make_bucket(bucket, &MakeBucketOptions::default())
.await
.expect("create bucket for incarnation validation");
let incarnation = store
.bucket_incarnation_id_from_disk(bucket)
.await
.expect("trusted incarnation");
let canonical = companion_snapshot(bucket, incarnation);
let bytes = serde_json::to_vec(&canonical).expect("encode canonical root with companion");
save_config(store.clone(), DATA_USAGE_OBJ_NAME_PATH.as_str(), bytes.clone())
.await
.expect("save canonical root");
clear_usage_memory_cache_for_test().await;
invalidate_data_usage_snapshot_cache().await;
let mut samples = Vec::new();
let mut rejected_writes = 0;
for _ in 0..2 {
let response = load_admin_data_usage_from_backend_cached(store.clone())
.await
.expect("read admin cache");
assert_eq!(response.buckets_usage[bucket].size, 250);
assert!(response.usage_snapshot_admin_projection);
replace_bucket_usage_memory_from_info(&response).await;
assert!(memory_cache().read().await.is_empty(), "response cannot seed quota memory");
let admin_bytes = response.buckets_usage[bucket].size;
let rejected = store_data_usage_in_backend(response, store.clone()).await.is_err();
assert!(rejected);
rejected_writes += usize::from(rejected);
let quota = load_data_usage_from_backend_cached(store.clone())
.await
.expect("read independent quota cache");
assert_eq!(quota.buckets_usage[bucket].size, 100);
assert!(!quota.usage_snapshot_admin_projection);
samples.push((admin_bytes, quota.buckets_usage[bucket].size));
invalidate_data_usage_snapshot_cache().await;
}
let persisted = read_config(store, DATA_USAGE_OBJ_NAME_PATH.as_str())
.await
.expect("read unchanged canonical root");
assert_eq!(persisted, bytes);
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-18", "assertion_id": "USAGE-18-A03", "status": "PASS",
"evidence": {"admin_and_quota_byte_samples": samples, "rejected_projected_writes": rejected_writes, "quota_memory_entries": memory_cache().read().await.len(), "persisted_canonical_unchanged": persisted == bytes}
})
);
let paths = _dirs.iter().map(|dir| dir.path().to_path_buf()).collect::<Vec<_>>();
drop(_dirs);
assert!(paths.iter().all(|path| !path.exists()));
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-18", "status": "PASS", "fixtures_removed": paths.iter().all(|path| !path.exists())})
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[serial]
async fn blocked_companion_identity_keeps_canonical_without_delaying_healthy_buckets() {
use crate::bucket::metadata_sys::{
acquire_metadata_transaction_guard, init_bucket_metadata_sys, test_support::isolated_store_over_temp_disks,
};
use crate::config::com::save_config;
use crate::storage_api_contracts::bucket::MakeBucketOptions;
// Admin reads also feed spawned metrics collectors across crate boundaries.
fn assert_send<T: Send>(future: T) -> T {
future
}
let (_dirs, store) = isolated_store_over_temp_disks().await;
init_bucket_metadata_sys(store.clone(), Vec::new()).await;
let blocked = "usage-blocked-identity";
let healthy = "usage-healthy-identity";
let mut snapshots = Vec::new();
for bucket in [blocked, healthy] {
store
.make_bucket(bucket, &MakeBucketOptions::default())
.await
.expect("create companion identity fixture");
let incarnation = store.bucket_incarnation_id_from_disk(bucket).await.expect("real incarnation");
snapshots.push(companion_snapshot(bucket, incarnation));
}
let mut canonical = snapshots.remove(0);
let other = snapshots.remove(0);
canonical.buckets_usage.extend(other.buckets_usage);
canonical.bucket_sizes.extend(other.bucket_sizes);
canonical
.usage_snapshot_bucket_observations
.extend(other.usage_snapshot_bucket_observations);
canonical.usage_snapshot_pending_buckets.push(healthy.to_string());
canonical.usage_snapshot_pending_bucket_count = 2;
canonical.buckets_count = 2;
canonical.calculate_totals();
save_config(
store.clone(),
DATA_USAGE_OBJ_NAME_PATH.as_str(),
serde_json::to_vec(&canonical).expect("encode both canonical values and companions"),
)
.await
.expect("persist usage fixture");
invalidate_data_usage_snapshot_cache().await;
let blocked_guard = acquire_metadata_transaction_guard(
store.clone(),
blocked,
"admin_identity_timeout_test",
rustfs_lock::LockType::Exclusive,
)
.await
.expect("hold the real bucket metadata writer lock");
let response = tokio::time::timeout(
ADMIN_USAGE_INCARNATION_TIMEOUT + Duration::from_secs(3),
assert_send(load_admin_data_usage_from_backend_cached(store.clone())),
)
.await
.expect("optional projection must return before the blocked metadata lock's long timeout")
.expect("canonical admin response stays available");
assert_eq!(response.buckets_usage[blocked].size, 100);
assert_eq!(response.buckets_usage[blocked].usage_value_state, Some(BucketUsageValueState::Carried));
assert_eq!(response.buckets_usage[healthy].size, 250);
assert_eq!(response.buckets_usage[healthy].usage_value_state, Some(BucketUsageValueState::Observed));
assert!(response.usage_snapshot_admin_projection);
assert!(
ADMIN_DATA_USAGE_SNAPSHOT_REFRESH
.get()
.expect("admin refresh mutex")
.try_lock()
.is_ok()
);
drop(blocked_guard);
invalidate_data_usage_snapshot_cache().await;
let recovered = load_admin_data_usage_from_backend_cached(store.clone())
.await
.expect("refresh after lock recovery");
assert_eq!(
recovered.buckets_usage[blocked].size, 250,
"unavailable identity can recover on the next refresh"
);
assert_eq!(recovered.buckets_usage[healthy].size, 250);
let quota = load_data_usage_from_backend_cached(store)
.await
.expect("separate canonical quota read");
assert_eq!(quota.buckets_usage[blocked].size, 100);
assert_eq!(quota.buckets_usage[healthy].size, 100);
}
@@ -0,0 +1,96 @@
// Copyright 2026 RustFS Team
// SPDX-License-Identifier: Apache-2.0
use super::*;
// Freeze the pre-companion reader's primary fields. Serde's unknown-field
// behavior models the existing JSON reader without importing the new schema.
#[derive(serde::Deserialize)]
struct LegacyPrimarySnapshot {
buckets_usage: HashMap<String, LegacyPrimaryBucket>,
bucket_sizes: HashMap<String, u64>,
objects_total_count: u64,
objects_total_size: u64,
#[serde(default)]
usage_snapshot_complete: bool,
}
#[derive(serde::Deserialize)]
struct LegacyPrimaryBucket {
size: u64,
objects_count: u64,
}
#[test]
fn usage_legacy_reader_never_promotes_companion_values_into_primary_lkg() {
let incarnation = uuid::Uuid::from_u128(31);
let mut snapshot = companion_snapshot("bucket", incarnation);
let original_certificate = snapshot.buckets_usage["bucket"].usage_certification;
let mut decoded_sizes = Vec::new();
for cycle in 10..=12 {
snapshot.scanner_cycle = Some(cycle);
let identity = snapshot.snapshot_identity();
snapshot
.usage_snapshot_bucket_observations
.get_mut("bucket")
.unwrap()
.snapshot_identity = identity;
let bytes = serde_json::to_vec(&snapshot).expect("production persisted snapshot encoding");
let old: LegacyPrimarySnapshot = serde_json::from_slice(&bytes).expect("old reader tolerates additive fields");
assert!(old.usage_snapshot_complete);
assert_eq!(old.buckets_usage["bucket"].size, 100);
assert_eq!(old.buckets_usage["bucket"].objects_count, 10);
assert_eq!(old.bucket_sizes["bucket"], 100);
assert_eq!(old.objects_total_size, 100);
assert_eq!(old.objects_total_count, 10);
let current = parse_usage_snapshot(&bytes).expect("current reader accepts persisted primary plus companion");
assert_eq!(current.buckets_usage["bucket"].usage_certification, original_certificate);
assert_eq!(current.usage_snapshot_bucket_observations["bucket"].usage.size, 250);
decoded_sizes.push(old.buckets_usage["bucket"].size);
}
snapshot.buckets_usage.clear();
snapshot.bucket_sizes.clear();
snapshot.buckets_count = 0;
snapshot.calculate_totals();
snapshot.usage_snapshot_complete = false;
snapshot.usage_snapshot_partial = true;
snapshot.usage_snapshot_observational = true;
snapshot.usage_snapshot_set_states[0].complete = false;
let bytes = serde_json::to_vec(&snapshot).expect("persisted companion-only encoding");
let old: LegacyPrimarySnapshot = serde_json::from_slice(&bytes).expect("old reader handles the absent baseline");
assert!(old.buckets_usage.is_empty() && old.bucket_sizes.is_empty());
assert!(!old.usage_snapshot_complete);
assert_eq!((old.objects_total_count, old.objects_total_size), (0, 0));
let current = parse_usage_snapshot(&bytes).expect("valid current observational snapshot");
assert!(current.is_valid_partial_snapshot());
assert_eq!(current.usage_snapshot_bucket_observations["bucket"].usage.size, 250);
assert_eq!(
snapshot.project_bucket_observations_for_admin(&HashMap::from([("bucket".into(), incarnation.to_string())])),
1
);
let response_bytes = serde_json::to_vec(&snapshot).expect("admin response encoding");
assert!(
parse_usage_snapshot(&response_bytes).is_err(),
"a projected response cannot be written as a baseline"
);
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-16", "assertion_id": "USAGE-16-A01", "status": "PASS",
"evidence": {
"wire_format": "production JSON, frozen legacy named primary fields",
"legacy_primary_sizes_across_rounds": decoded_sizes,
"new_companion_size": 250,
"companion_only_legacy_primary_count": old.buckets_usage.len(),
"companion_only_legacy_complete": old.usage_snapshot_complete,
"projected_response_rejected_by_persistence_parser": true
}
})
);
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-16", "status": "PASS", "scope": "process-local"})
);
}
+11
View File
@@ -345,6 +345,7 @@ const DISK_OPERATION_NAMES: &[&str] = &[
"read_parts",
"read_multiple",
"write_all",
"write_format_control",
"compare_and_update_file",
"read_all",
];
@@ -3662,6 +3663,16 @@ impl DiskAPI for LocalDiskWrapper {
.await
}
async fn write_format_control(&self, path: &str, data: Bytes) -> Result<()> {
self.track_disk_health_mutation(
"write_format_control",
DiskMetricMutation::Write,
|| async { self.disk.write_format_control(path, data).await },
get_max_timeout_duration(),
)
.await
}
async fn compare_and_update_file(
&self,
volume: &str,
+1
View File
@@ -179,6 +179,7 @@ fn is_windows_dir_access_denied(_path: &Path, _e: &io::Error) -> bool {
false
}
#[cfg(test)]
#[tracing::instrument(level = "debug", skip_all)]
pub async fn remove(path: impl AsRef<Path>) -> io::Result<()> {
let path = path.as_ref().to_path_buf();
File diff suppressed because it is too large Load Diff
+61 -46
View File
@@ -504,6 +504,10 @@ impl LocalDisk {
dst_path: &str,
state: &mut RenameDataState,
) -> Result<RenameDataResp> {
state.namespace_owner = self.usage_watch_binding.owner(dst_volume, state.namespace_owner.take());
if src_volume != dst_volume {
state.namespace_owner = self.usage_watch_binding.owner(src_volume, state.namespace_owner.take());
}
super::multipart_staging::reject_noncanonical_scope(&self.root, self.io_root(), src_volume, src_path).inspect_err(
|_| {
state.preflight_rejection = Some(LocalRenamePreflightRejection(()));
@@ -841,17 +845,20 @@ impl LocalDisk {
run_inline_before_file_sync_admission(dst_path);
}
let sync_data_shards = no_inline && durability.syncs_data_shards();
let sync_commit_metadata = durability.syncs_commit_metadata();
let file_sync_admission = if sync_data_shards || sync_commit_metadata {
Some(
os::acquire_file_sync_admission(self.file_sync_permits.clone())
.await
.map_err(to_file_error)
.map_err(DiskError::from)?,
)
} else {
None
};
let sync_metadata_files = durability.syncs_metadata_files();
let sync_commit_directories = durability.syncs_commit_directories();
let sync_recovery_protocol = durability.syncs_recovery_protocol_state();
let file_sync_admission =
if sync_data_shards || sync_metadata_files || sync_commit_directories || sync_recovery_protocol {
Some(
os::acquire_file_sync_admission(self.file_sync_permits.clone())
.await
.map_err(to_file_error)
.map_err(DiskError::from)?,
)
} else {
None
};
let src_parent_owned = src_file_parent.to_path_buf();
let dst_parent_owned = dst_file_parent.to_path_buf();
let src_file_path_owned = src_file_path.clone();
@@ -962,7 +969,7 @@ impl LocalDisk {
&dst_file_path_owned,
&src_file_path_owned,
old_metadata,
sync_commit_metadata,
sync_recovery_protocol,
) {
Ok(path) => path,
Err(err) => {
@@ -975,15 +982,33 @@ impl LocalDisk {
}
if no_inline {
if sync_data_shards && let Some((src_data_path, _)) = has_data_dir_path_owned.as_ref() {
let sync_result = if !probe_active && super::take_presynced_tmp_data_dir(src_data_path) {
// The payload was synced, but its part.1 directory entry
// must also be persisted before moving the data directory.
os::fsync_dir_std(src_data_path)
} else {
os::sync_dir_files_std(src_data_path)
};
if let Err(err) = sync_result
let presynced_data_dir = sync_data_shards
&& !probe_active
&& has_data_dir_path_owned
.as_ref()
.is_some_and(|(src_data_path, _)| super::take_presynced_tmp_data_dir(src_data_path));
if !presynced_data_dir
&& sync_data_shards
&& let Some((src_data_path, _)) = has_data_dir_path_owned.as_ref()
&& let Err(err) = os::sync_dir_files_std(src_data_path)
&& err.kind() != ErrorKind::NotFound
{
if let Some(backup_path) = staged_rollback_path.as_ref().map(StagedRollbackBackup::path) {
let _ = remove_file_if_exists(backup_path);
}
return Err(err);
}
if sync_metadata_files && let Err(err) = prepared_metadata_source.sync_data() {
if let Some(backup_path) = staged_rollback_path.as_ref().map(StagedRollbackBackup::path) {
let _ = remove_file_if_exists(backup_path);
}
return Err(err);
}
if presynced_data_dir && let Some((src_data_path, _)) = has_data_dir_path_owned.as_ref() {
// The payload was synced, and prepared_metadata_source.sync_data()
// committed the active journal transaction; persist src_data_path's
// directory entry before moving the data directory.
if let Err(err) = os::fsync_dir_std(src_data_path)
&& err.kind() != ErrorKind::NotFound
{
if let Some(backup_path) = staged_rollback_path.as_ref().map(StagedRollbackBackup::path) {
@@ -992,13 +1017,7 @@ impl LocalDisk {
return Err(err);
}
}
if sync_commit_metadata && let Err(err) = prepared_metadata_source.sync_data() {
if let Some(backup_path) = staged_rollback_path.as_ref().map(StagedRollbackBackup::path) {
let _ = remove_file_if_exists(backup_path);
}
return Err(err);
}
} else if sync_commit_metadata && let Err(err) = prepared_metadata_source.sync_data() {
} else if sync_metadata_files && let Err(err) = prepared_metadata_source.sync_data() {
drop(prepared_metadata_source);
cleanup_flat_tmp();
if let Some(backup_path) = staged_rollback_path.as_ref().map(StagedRollbackBackup::path) {
@@ -1089,8 +1108,8 @@ impl LocalDisk {
if let Err(err) = backup_path_guard.write_file_for_path_access(
&backup_path,
dst_buf.as_ref(),
sync_commit_metadata,
sync_commit_metadata,
sync_recovery_protocol,
sync_recovery_protocol,
) {
return Ok(FusedCommitAttempt::RestoreDataSource(guard, to_file_error(err).into()));
}
@@ -1109,7 +1128,7 @@ impl LocalDisk {
&skip_parent,
&publication_root_owned,
None,
sync_commit_metadata,
sync_recovery_protocol,
) {
drop(prepared_metadata_source);
cleanup_flat_tmp();
@@ -1162,7 +1181,7 @@ impl LocalDisk {
return Ok(FusedCommitAttempt::CommitErr(DiskError::Unexpected));
}
if sync_commit_metadata {
if sync_commit_directories {
if staged_rollback_path.is_none()
&& rollback_data_dir.is_none()
&& let Some(ref old_metadata) = has_dst_buf
@@ -1304,7 +1323,7 @@ impl LocalDisk {
let publication_root_owned = self.publication_root.clone();
let has_data_dir_path_owned = has_data_dir_path.clone();
let sync_data_shards = durability.syncs_data_shards();
let sync_commit_metadata = durability.syncs_commit_metadata();
let sync_commit_directories = durability.syncs_commit_directories();
let staging_cleanup = multipart_staging.as_ref().map(|s| s.cleanup_handle());
let dst_volume_str = dst_volume.to_string();
let dst_path_str = dst_path.to_string();
@@ -1456,7 +1475,7 @@ impl LocalDisk {
if crash_inject::should_crash_at(CrashPoint::RenameAfterMetaCommit, &dst_path_str) {
return Ok(MultipartFusedCommitOutcome::AbortBeforeDataRename(DiskError::Unexpected));
}
if sync_commit_metadata {
if sync_commit_directories {
if let Some(parent) = dst_file_path_owned.parent()
&& let Err(err) = os::fsync_commit_directory_limited_std(parent, &directory_guard_owned)
{
@@ -1489,7 +1508,7 @@ impl LocalDisk {
}
}
match publication_owned.finish_on_thread(
sync_commit_metadata,
durability.fully_syncs_commit_target(),
!cfg!(test),
staging_cleanup,
Some(&directory_guard_owned),
@@ -1608,7 +1627,7 @@ impl LocalDisk {
.await?;
// This is system metadata authority, so use its existing strict
// durability policy even when the object payload is relaxed.
if effective_durability(src_volume).syncs_commit_metadata() {
if effective_durability(src_volume).syncs_recovery_protocol_state() {
os::fsync_dir_with_owner(recovery.parent().ok_or(DiskError::InvalidPath)?, Some(authority_owner.clone()))
.await
.map_err(to_file_error)?;
@@ -1715,7 +1734,7 @@ impl LocalDisk {
shard_sync_res?;
prepared_metadata_source
} else {
let tmp_meta_sync = if durability.syncs_commit_metadata() {
let tmp_meta_sync = if durability.syncs_metadata_files() {
SyncMode::FileOnly
} else {
SyncMode::None
@@ -1862,11 +1881,7 @@ impl LocalDisk {
// it keeps SyncMode::FileAndDir: contents and directory entry both
// durable. It is part of the metadata commit machinery, so relaxed
// tiers leave it to the page cache like the xl.meta it mirrors.
let backup_sync = if durability.syncs_commit_metadata() {
SyncMode::FileAndDir
} else {
SyncMode::None
};
let backup_sync = durability.recovery_sync_mode();
if let (Some(old_data_dir), Some(dst_buf)) = (rollback_data_dir, has_dst_buf.as_ref())
&& multipart_publication.as_ref().is_none_or(|publication| publication.legacy)
{
@@ -1983,7 +1998,7 @@ impl LocalDisk {
// Persist the directory entries for both the data dir and xl.meta renames;
// without this the commit itself can vanish on power loss. Relaxed tiers
// accept that window (documented in docs/operations/durability-modes.md).
if durability.syncs_commit_metadata()
if durability.syncs_commit_directories()
&& let Some(parent) = dst_file_path.parent()
{
let fsync_started = rustfs_io_metrics::put_stage_timer();
@@ -2023,7 +2038,7 @@ impl LocalDisk {
// are durable. Overwrites already have a durable object dir. The
// starts_with guard bounds the walk to the bucket subtree. Relaxed/none
// accept the wider window, like the commit fsync above.
if has_dst_buf.is_none() && durability.syncs_commit_metadata() {
if has_dst_buf.is_none() && durability.syncs_commit_directories() {
let mut ancestor = dst_file_path.parent().and_then(|object_dir| object_dir.parent());
while let Some(dir) = ancestor {
if !dir.starts_with(&dst_volume_dir) {
@@ -2090,7 +2105,7 @@ impl LocalDisk {
let multipart_source = match multipart_publication.as_ref() {
Some(publication) => {
let target_already_synced = durability.syncs_commit_metadata();
let target_already_synced = durability.fully_syncs_commit_target();
let staging_cleanup = multipart_staging.as_ref().map(|s| s.cleanup_handle());
match pin_multipart_future(|| {
publication.finish(commit.mutation_lease.clone(), target_already_synced, staging_cleanup)
@@ -2136,7 +2151,7 @@ impl LocalDisk {
#[cfg(windows)]
let source_parent = src_file_parent.to_path_buf();
let rename_commit_guard_for_preparation = commit.directory_guard.clone();
let sync = durability.syncs_commit_metadata();
let sync = durability.syncs_recovery_protocol_state();
#[cfg(unix)]
let receipt_identity = if sync
&& pool_meta_condition
+444 -29
View File
@@ -1867,7 +1867,7 @@ impl LocalDisk {
let destination = root.join(transaction.to_string());
let destination_was_absent = original.is_none();
let original = original.map(<[u8]>::to_vec);
let sync = effective_durability(volume).syncs_commit_metadata();
let sync = effective_durability(volume).syncs_recovery_protocol_state();
#[cfg(test)]
let record_destination = destination.clone();
let staging_root = temporary;
@@ -1925,28 +1925,40 @@ impl LocalDisk {
// The directory owner accompanies the blocking rename, so cancelling
// its waiter cannot delete staged files while activation is running.
let publication_owner: Option<Arc<dyn Send + Sync>> = Some(Arc::new((owner.clone(), staged.clone())));
os::rename_all_with_owner(staged.path(), &destination, &bucket, &self.publication_root, publication_owner).await?;
if sync {
let mut dirs_to_sync = Vec::new();
let mut path = root.as_path();
loop {
dirs_to_sync.push(path.to_path_buf());
if !destination_was_absent || path == bucket {
break;
// Rename and its directory syncs share one fsync-lane closure; the
// one-worker foreground lane serves metadata reads. The pinned
// parent is `root`; a new object also persists its ancestors.
let mut ancestors = Vec::new();
if destination_was_absent {
let mut path = root.as_path();
while path != bucket {
path = path.parent().ok_or(DiskError::InvalidPath)?;
ancestors.push(path.to_path_buf());
}
path = path.parent().ok_or(DiskError::InvalidPath)?;
}
let sync_owner = owner.clone();
self.blocking_queue
.run_fsync_cancellable(move |_| {
let _owner = sync_owner;
for dir in dirs_to_sync {
os::fsync_dir_std(&dir)?;
}
Ok(())
})
.await
.map_err(to_file_error)?;
let source = staged.path().to_path_buf();
let publication_root = self.publication_root.clone();
os::record_native_publication(&destination);
let lease = os::acquire_namespace_mutation_lease_with_owner(&destination, publication_owner).await;
os::run_blocking_namespace_operation_with_sync(lease, true, move || {
os::rename_all_with_precondition_and_parent_sync_std(
&source,
&destination,
&bucket,
&publication_root,
None,
true,
)?;
for dir in ancestors {
os::fsync_dir_std(&dir)?;
}
Ok(())
})
.await
.map_err(to_file_error)?;
} else {
os::rename_all_with_owner(staged.path(), &destination, &bucket, &self.publication_root, publication_owner).await?;
}
self.delete_recovery_barrier(volume, object, transaction, "PREPARED").await?;
Ok(target)
@@ -2138,6 +2150,7 @@ impl LocalDisk {
action: DeleteRecoveryAction,
owner: Option<Arc<dyn Send + Sync>>,
) -> Result<DeleteRecoveryInspection> {
let owner = self.usage_watch_binding.owner(volume, owner);
self.reject_multipart_delete_recovery_mutation(volume, object)?;
if let Ok(root) = self.io_get_object_path(volume, object) {
let tx_dir = root.join(transaction.to_string());
@@ -2331,7 +2344,7 @@ impl LocalDisk {
Err(err) if err.kind() == ErrorKind::NotFound => {}
Err(err) => return Err(to_file_error(err).into()),
}
if effective_durability(volume).syncs_commit_metadata() {
if effective_durability(volume).syncs_recovery_protocol_state() {
os::fsync_dir_with_owner(&dir, owner.clone()).await.map_err(to_file_error)?;
}
if self
@@ -2359,7 +2372,9 @@ impl LocalDisk {
Err(err) => return Err(to_file_error(err).into()),
}
}
if effective_durability(volume).syncs_commit_metadata() && fs::try_exists(&rollback).await.map_err(to_file_error)? {
if effective_durability(volume).syncs_recovery_protocol_state()
&& fs::try_exists(&rollback).await.map_err(to_file_error)?
{
os::fsync_dir_with_owner(&rollback, owner.clone())
.await
.map_err(to_file_error)?;
@@ -2443,7 +2458,7 @@ impl LocalDisk {
None,
)
.await?;
if effective_durability(volume).syncs_commit_metadata() {
if effective_durability(volume).syncs_recovery_protocol_state() {
os::fsync_dir_with_owner(&root, owner.clone()).await.map_err(to_file_error)?;
}
}
@@ -2454,7 +2469,7 @@ impl LocalDisk {
os::remove_files_and_fsync_with_owner(
&rollback,
&[STORAGE_FORMAT_FILE_BACKUP, DELETE_MARKER_ROLLBACK_FILE],
effective_durability(volume).syncs_commit_metadata(),
effective_durability(volume).syncs_recovery_protocol_state(),
None,
owner.clone(),
)
@@ -2487,7 +2502,7 @@ impl LocalDisk {
Err(err) if err.kind() == ErrorKind::NotFound => {}
Err(err) => return Err(to_file_error(err).into()),
}
if effective_durability(volume).syncs_commit_metadata() {
if effective_durability(volume).syncs_recovery_protocol_state() {
os::fsync_dir_with_owner(&staged, owner.clone())
.await
.map_err(to_file_error)?;
@@ -2568,7 +2583,7 @@ impl LocalDisk {
let lease = os::acquire_namespace_mutation_lease_with_owner(&dir, owner.clone()).await;
prune_dirs.push((dir, lease));
}
let sync = effective_durability(volume).syncs_commit_metadata();
let sync = effective_durability(volume).syncs_recovery_protocol_state();
let (rollback_buf, root_buf, volume_str, object_str) =
(rollback.clone(), root.clone(), volume.to_owned(), object.to_owned());
let publication_root = self.publication_root.clone();
@@ -2789,7 +2804,7 @@ impl LocalDisk {
} else {
self.io_get_bucket_path(RUSTFS_META_TMP_BUCKET)?
};
let sync = effective_durability(volume).syncs_commit_metadata();
let sync = effective_durability(volume).syncs_recovery_protocol_state();
let incarnation = opts.delete_recovery_bucket_incarnation;
let lease = os::acquire_namespace_mutation_lease_with_owner(&destination, owner).await;
let fi_clone = fi.clone();
@@ -3175,6 +3190,7 @@ impl LocalDisk {
namespace_owner: Option<Arc<dyn Send + Sync>>,
work_budget: Option<Arc<crate::object_api::DeleteRecoveryWorkBudget>>,
) -> Result<Option<(DeleteRecoveryJournal, bool, bool)>> {
let namespace_owner = self.usage_watch_binding.owner(volume, namespace_owner);
if transaction.is_nil() {
return Err(DiskError::InvalidPath);
}
@@ -3221,7 +3237,7 @@ impl LocalDisk {
let owner: Option<Arc<dyn Send + Sync>> = Some(Arc::new((metadata_owner, volume_guard)));
let rollback = root.join(transaction.to_string());
let receipt_path = rollback.join(DELETE_QUORUM_COMMITTED_FILE);
let sync = effective_durability(volume).syncs_commit_metadata();
let sync = effective_durability(volume).syncs_recovery_protocol_state();
let lease = os::acquire_namespace_mutation_lease_with_owner(&receipt_path, owner).await;
let volume_str = volume.to_owned();
let object_str = object.to_owned();
@@ -3397,6 +3413,7 @@ impl LocalDisk {
namespace_owner: Option<Arc<dyn Send + Sync>>,
work_budget: Option<Arc<crate::object_api::DeleteRecoveryWorkBudget>>,
) -> Result<bool> {
let namespace_owner = self.usage_watch_binding.owner(volume, namespace_owner);
fn ignore_not_found(res: std::io::Result<()>) -> std::io::Result<()> {
match res {
Ok(()) => Ok(()),
@@ -3463,7 +3480,7 @@ impl LocalDisk {
let owner: Option<Arc<dyn Send + Sync>> = Some(Arc::new((metadata_owner, volume_guard)));
let rollback = root.join(transaction.to_string());
let receipt_path = rollback.join(DELETE_QUORUM_COMMITTED_FILE);
let sync = effective_durability(volume).syncs_commit_metadata();
let sync = effective_durability(volume).syncs_recovery_protocol_state();
let mut claims: Vec<SnapshotLeaseDeleteClaim> = Vec::with_capacity(journal.data_dirs.len());
for data_dir in &journal.data_dirs {
@@ -4816,6 +4833,404 @@ mod tests {
assert!(temp.path().join("recovery").is_dir(), "finalization must preserve its original volume");
}
#[cfg(unix)]
#[tokio::test]
async fn delete_recovery_activation_leaves_metadata_reads_on_foreground_lane() {
assert_activation_leaves_metadata_reads_on_foreground_lane("object", |disk, transaction| async move {
let result = disk
.delete_versions_recoverable(
"recovery",
vec![super::super::FileInfoVersions {
name: "object".to_owned(),
versions: vec![request()],
..Default::default()
}],
DeleteOptions {
old_data_dir: Some(transaction),
..Default::default()
},
)
.await;
if result.len() == 1 && result[0].is_none() {
Ok(())
} else {
Err(format!("{result:?}"))
}
})
.await;
}
#[cfg(unix)]
#[tokio::test]
async fn delete_recovery_missing_original_activation_leaves_metadata_reads_on_foreground_lane() {
assert_activation_leaves_metadata_reads_on_foreground_lane("prefix/missing", |disk, transaction| async move {
let marker = FileInfo {
name: "prefix/missing".to_owned(),
version_id: Some(Uuid::new_v4()),
deleted: true,
mod_time: Some(OffsetDateTime::now_utc()),
..Default::default()
};
let context = DeletePreparationContext {
transaction,
bucket_incarnation: None,
namespace_owner: None,
};
match disk
.prepare_delete_recovery("recovery", "prefix/missing", None, &[marker], None, context)
.await
{
Ok(Some(_)) => Ok(()),
other => Err(format!("{other:?}")),
}
})
.await;
}
/// Pause the actual activation rename and require an unrelated metadata
/// read on the same disk to complete before the rename is released.
#[cfg(unix)]
async fn assert_activation_leaves_metadata_reads_on_foreground_lane<Fut>(
object: &str,
activate: impl FnOnce(Arc<LocalDisk>, Uuid) -> Fut,
) where
Fut: std::future::Future<Output = std::result::Result<(), String>> + Send + 'static,
{
use crate::disk::os::prepared_publication_test_hooks as hooks;
let _mode = durability_mode_override::set(DurabilityMode::Strict);
let (temp, disk, _, _) = fixture().await;
let disk = Arc::new(disk);
let metadata = temp.path().join("unrelated-metadata");
fs::write(&metadata, b"readable during activation")
.await
.expect("unrelated metadata fixture");
let transaction = Uuid::new_v4();
let destination = disk
.io_get_object_path("recovery", &format!("{object}/{transaction}"))
.expect("transaction path");
let staging_root = disk.io_get_bucket_path(RUSTFS_META_TMP_BUCKET).expect("staging root");
let (observer_tx, observer_rx) = tokio::sync::oneshot::channel();
let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
let (release_tx, release_rx) = std::sync::mpsc::channel();
let expected_destination = destination.clone();
set_owned_file_before_open(&destination.join(PREPARED), move || {
let stages: Vec<_> = std::fs::read_dir(&staging_root)
.expect("staging directory")
.map(|entry| entry.expect("staging entry").path())
.filter(|path| {
path.file_name()
.is_some_and(|name| name.to_string_lossy().starts_with("delete-preparation-"))
})
.collect();
assert_eq!(stages.len(), 1, "the isolated fixture has one pending preparation");
// Unlike a Stage::Rename pause, this observer does not add a replacement lane worker.
let observer = hooks::observe_rename_destination(&stages[0], move |destination| {
assert_eq!(destination, expected_destination);
let _ = entered_tx.send(());
let _ = release_rx.recv_timeout(Duration::from_secs(10));
});
let _ = observer_tx.send(observer);
});
let task = tokio::spawn(activate(Arc::clone(&disk), transaction));
let observer = tokio::time::timeout(Duration::from_secs(5), observer_rx).await;
let entered = tokio::time::timeout(Duration::from_secs(5), entered_rx).await;
let read = tokio::time::timeout(
Duration::from_secs(1),
disk.run_metadata_read(None, metadata, |opened| {
let mut file = opened?;
let mut bytes = Vec::new();
std::io::Read::read_to_end(&mut file, &mut bytes)?;
Ok::<_, std::io::Error>(bytes)
}),
)
.await;
let _ = release_tx.send(());
let activated = tokio::time::timeout(Duration::from_secs(5), task)
.await
.expect("activation finishes after release")
.expect("activation task joined");
drop(observer.expect("preparation registered observer").expect("observer received"));
entered.expect("actual rename reached").expect("rename observation received");
activated.expect("recoverable activation succeeds");
assert_eq!(
read.expect("metadata reads must progress while activation is paused")
.expect("metadata read queued")
.expect("metadata read completed"),
b"readable during activation"
);
}
#[cfg(unix)]
#[tokio::test]
async fn delete_recovery_activation_preserves_sync_modes_and_rollback() {
for mode in [DurabilityMode::Strict, DurabilityMode::Relaxed, DurabilityMode::None] {
let _mode = durability_mode_override::set(mode);
let (_temp, disk, _, original) = fixture().await;
let root = disk.io_get_object_path("recovery", "object").expect("object path");
// The next fixture can reuse this disk's fd alias; compare physical paths.
let recorded_root = root.canonicalize().expect("physical object path");
assert!(!os::fsync_dir_recorder::was_fsynced(&recorded_root), "fresh object sync history");
let transaction = Uuid::new_v4();
let result = disk
.delete_versions_recoverable(
"recovery",
vec![super::super::FileInfoVersions {
name: "object".to_owned(),
versions: vec![request()],
..Default::default()
}],
DeleteOptions {
old_data_dir: Some(transaction),
..Default::default()
},
)
.await;
assert_eq!(result.len(), 1);
assert!(result[0].is_none(), "prepare deletion in {mode:?}: {result:?}");
assert_eq!(
os::fsync_dir_recorder::was_fsynced(&recorded_root),
mode == DurabilityMode::Strict,
"activation must preserve the selected metadata sync mode"
);
let prepared = disk
.inspect_delete_transaction("recovery", "object", transaction)
.await
.expect("inspect applied preparation");
assert_eq!(prepared.state, DeleteRecoveryState::NewPrepared);
assert_eq!(prepared.backup_digest, Some(digest(&original)));
assert!(prepared.current_digest.is_none(), "delete is applied before its receipt is published");
let restored = disk
.settle_delete_transaction(
"recovery",
"object",
transaction,
prepared.fingerprint,
DeleteRecoveryAction::Rollback,
)
.await
.expect("roll back unpublished deletion");
assert_eq!(restored.state, DeleteRecoveryState::Absent);
assert_eq!(fs::read(root.join(STORAGE_FORMAT_FILE)).await.expect("restored metadata"), original);
assert!(!root.join(transaction.to_string()).exists(), "rollback removes its transaction");
}
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn delete_recovery_existing_activation_records_native_publication_before_rename() {
use crate::disk::os::prepared_publication_test_hooks as hooks;
use std::sync::atomic::{AtomicBool, Ordering};
let _mode = durability_mode_override::set(DurabilityMode::Strict);
let (_temp, disk, _, original) = fixture().await;
let bucket = format!("activation-history-{}", Uuid::new_v4());
let object = "prefix/object";
let witness = disk
.publication_history
.as_ref()
.expect("native publication history")
.witness(&bucket, Uuid::new_v4(), Arc::clone(&disk.io_backend))
.expect("fresh bucket publication history");
let root = disk.io_get_object_path(&bucket, object).expect("existing nested object path");
// Seed existing parents without consuming the history being tested at activation.
std::fs::create_dir_all(&root).expect("raw existing hierarchy");
std::fs::write(root.join(STORAGE_FORMAT_FILE), &original).expect("raw original metadata");
assert!(os::validate_native_creation_witnesses(std::slice::from_ref(&witness)));
let transaction = Uuid::new_v4();
let observed = Arc::new(AtomicBool::new(false));
let hook_observed = Arc::clone(&observed);
let _hook = hooks::install_at(hooks::Stage::Rename, &root.join(transaction.to_string()), move || {
assert!(
!os::validate_native_creation_witnesses(std::slice::from_ref(&witness)),
"activation must consume history before the native rename runs"
);
hook_observed.store(true, Ordering::Release);
});
disk.prepare_delete_recovery(
&bucket,
object,
Some(&original),
&[request()],
None,
DeletePreparationContext {
transaction,
bucket_incarnation: None,
namespace_owner: None,
},
)
.await
.expect("activate existing nested object preparation");
assert!(observed.load(Ordering::Acquire), "the actual activation rename hook must run");
}
#[cfg(unix)]
#[tokio::test]
async fn delete_recovery_activation_sync_failure_preserves_original_and_preparation() {
let _mode = durability_mode_override::set(DurabilityMode::Strict);
let (_temp, disk, _, original) = fixture().await;
let root = disk.io_get_object_path("recovery", "object").expect("object path");
let transaction = Uuid::new_v4();
os::fsync_dir_recorder::set_failure(&root, ErrorKind::Other);
let result = disk
.delete_versions_recoverable(
"recovery",
vec![super::super::FileInfoVersions {
name: "object".to_owned(),
versions: vec![request()],
..Default::default()
}],
DeleteOptions {
old_data_dir: Some(transaction),
..Default::default()
},
)
.await;
assert_eq!(result.len(), 1);
assert!(result[0].is_some(), "activation sync failure must reach the caller");
assert!(os::fsync_dir_recorder::take_failure(&root).is_none(), "the injected failure was consumed");
assert_eq!(fs::read(root.join(STORAGE_FORMAT_FILE)).await.expect("unchanged head"), original);
let prepared = disk
.inspect_delete_transaction("recovery", "object", transaction)
.await
.expect("inspect failed activation");
assert_eq!(prepared.state, DeleteRecoveryState::NewPrepared);
assert_eq!(prepared.backup_digest, Some(digest(&original)));
assert_eq!(prepared.current_digest, Some(digest(&original)));
let restored = disk
.settle_delete_transaction("recovery", "object", transaction, prepared.fingerprint, DeleteRecoveryAction::Rollback)
.await
.expect("retry can settle failed activation");
assert_eq!(restored.state, DeleteRecoveryState::Absent);
assert_eq!(fs::read(root.join(STORAGE_FORMAT_FILE)).await.expect("settled head"), original);
}
#[cfg(unix)]
#[tokio::test]
async fn delete_recovery_activation_owner_outlives_cancelled_parent_sync() {
use crate::disk::os::prepared_publication_test_hooks as hooks;
use futures::FutureExt;
let _mode = durability_mode_override::set(DurabilityMode::Strict);
let (temp, disk, _, original) = fixture().await;
let disk = Arc::new(disk);
let transaction = Uuid::new_v4();
let root = disk.io_get_object_path("recovery", "object").expect("object path");
let (entered_tx, entered_rx) = tokio::sync::oneshot::channel();
let (release_tx, release_rx) = std::sync::mpsc::channel();
let hook = hooks::install_at(hooks::Stage::DirFsync, &root, move || {
let _ = entered_tx.send(());
let _ = release_rx.recv_timeout(Duration::from_secs(10));
});
let deleting = Arc::clone(&disk);
let task = tokio::spawn(async move {
deleting
.delete_versions_recoverable(
"recovery",
vec![super::super::FileInfoVersions {
name: "object".to_owned(),
versions: vec![request()],
..Default::default()
}],
DeleteOptions {
old_data_dir: Some(transaction),
..Default::default()
},
)
.await
});
let mut removal = None;
let observations = std::panic::AssertUnwindSafe(async {
tokio::time::timeout(Duration::from_secs(5), entered_rx)
.await
.expect("activation reached parent sync")
.expect("parent sync observation received");
assert!(root.join(transaction.to_string()).join(PREPARED).is_file());
assert_eq!(fs::read(root.join(STORAGE_FORMAT_FILE)).await.expect("head before sync"), original);
task.abort();
assert!(task.await.expect_err("delete waiter was cancelled").is_cancelled());
let removing = Arc::clone(&disk);
removal = Some(tokio::spawn(async move { removing.delete_volume("recovery", true).await }));
assert!(
tokio::time::timeout(Duration::from_millis(100), removal.as_mut().expect("volume removal started"))
.await
.is_err(),
"the active sync must retain the volume mutation owner after cancellation"
);
assert!(root.join(transaction.to_string()).join(STORAGE_FORMAT_FILE_BACKUP).is_file());
})
.catch_unwind()
.await;
let _ = release_tx.send(());
drop(hook);
if let Some(removal) = removal {
tokio::time::timeout(Duration::from_secs(5), removal)
.await
.expect("volume removal resumes after sync")
.expect("volume removal joined")
.expect("volume removal succeeds");
}
if let Err(panic) = observations {
std::panic::resume_unwind(panic);
}
disk.make_volume("recovery")
.await
.expect("recreate volume after sync drained");
assert!(
!temp.path().join("recovery/object").exists(),
"cancelled activation cannot publish into the new volume"
);
}
#[cfg(unix)]
#[tokio::test]
async fn delete_recovery_missing_original_preparation_syncs_ancestors() {
let _mode = durability_mode_override::set(DurabilityMode::Strict);
let (_temp, disk, _, _) = fixture().await;
let object = "prefix/missing";
let root = disk.io_get_object_path("recovery", object).expect("missing object path");
let transaction = Uuid::new_v4();
let marker = FileInfo {
name: object.to_owned(),
version_id: Some(Uuid::new_v4()),
deleted: true,
mod_time: Some(OffsetDateTime::now_utc()),
..Default::default()
};
let target = disk
.prepare_delete_recovery(
"recovery",
object,
None,
&[marker],
None,
DeletePreparationContext {
transaction,
bucket_incarnation: None,
namespace_owner: None,
},
)
.await
.expect("prepare missing-object marker");
assert!(target.is_some(), "the marker has a planned metadata target");
for directory in [
&root,
root.parent().expect("prefix"),
root.parent().and_then(Path::parent).expect("bucket"),
] {
// Physical paths: a reused fd alias from another test cannot match.
let physical = directory.canonicalize().expect("physical ancestor path");
assert!(os::fsync_dir_recorder::was_fsynced(&physical), "persist created ancestors: {physical:?}");
}
let prepared = disk
.inspect_delete_transaction("recovery", object, transaction)
.await
.expect("inspect missing-object preparation");
assert_eq!(prepared.state, DeleteRecoveryState::NewPrepared);
assert!(prepared.backup_digest.is_none());
assert!(prepared.current_digest.is_none());
}
#[cfg(unix)]
#[tokio::test]
async fn delete_recovery_activation_is_complete_before_metadata_mutation_even_after_cancel() {
@@ -125,6 +125,80 @@ async fn commit_actual_abort(fixture: &Fixture, certificate: &MultipartAbortCert
}
}
#[cfg(target_os = "linux")]
#[tokio::test]
async fn native_abort_late_part_settlement_preserves_the_retired_tree() {
use crate::disk::{PartTransactionAction, RUSTFS_META_TMP_BUCKET};
let fixture = heap_native(Fixture::new).await;
let disk = &fixture.disks[0];
for volume in [RUSTFS_META_TMP_BUCKET, RUSTFS_META_TMP_DELETED_BUCKET] {
match disk.make_volume(volume).await {
Ok(()) | Err(DiskError::VolumeExists) => {}
Err(error) => panic!("prepare the part/retirement volume: {error}"),
}
}
let snapshot = heap_native(|| fixture.snapshot(0)).await;
let destination = format!("{}/{}/part.1", fixture.path, snapshot.lineage.original_data_dir);
let body = bytes::Bytes::from_static(b"replacement shard");
let part = ObjectPartInfo {
number: 1,
size: body.len(),
actual_size: i64::try_from(body.len()).expect("fixture shard size fits i64"),
etag: "replacement".to_owned(),
..Default::default()
};
let metadata = bytes::Bytes::from(part.marshal_msg().expect("part transaction metadata"));
disk.write_all(RUSTFS_META_TMP_BUCKET, "late-settle/part.1", body)
.await
.expect("stage the replacement shard");
disk.prepare_part_transaction(
RUSTFS_META_TMP_BUCKET,
"late-settle/part.1",
RUSTFS_META_MULTIPART_BUCKET,
&destination,
metadata.clone(),
)
.await
.expect("prepare the replacement transaction");
disk.rename_part(
RUSTFS_META_TMP_BUCKET,
"late-settle/part.1",
RUSTFS_META_MULTIPART_BUCKET,
&destination,
metadata,
)
.await
.expect("publish the replacement before retaining its settlement");
let transaction = disk
.io_get_object_open_path(RUSTFS_META_MULTIPART_BUCKET, &crate::disk::part_transaction_path(&destination))
.expect("published transaction cache key");
assert!(
crate::disk::local::PUBLISHED_PART_TXN_RECEIPTS
.with_get(&transaction, |receipt| receipt.txn_parent_fd.is_some())
.unwrap_or(false),
"the real part APIs must retain their pinned transaction parent"
);
let certificate = heap_native(|| prepare_actual_abort(&fixture)).await;
heap_native(|| commit_actual_abort(&fixture, &certificate)).await;
disk.recover_multipart_source(fixture.request(MultipartSourceOperation::DeleteAborted {
expected: heap_native(|| fixture.snapshot(0)).await,
certificate,
}))
.await
.expect("retire the actual upload into its ordinary trash tree");
assert!(!source_root(&fixture, 0).exists());
let trash = disk.root.join(RUSTFS_META_TMP_DELETED_BUCKET);
let before = exact_tree(&trash);
assert!(!before.is_empty(), "retirement must retain the real transaction in trash");
disk.settle_part_transaction(RUSTFS_META_MULTIPART_BUCKET, &destination, PartTransactionAction::Commit)
.await
.expect("an absent canonical transaction is already settled");
assert!(!source_root(&fixture, 0).exists(), "late settlement must not recreate the upload");
assert_eq!(exact_tree(&trash), before, "late settlement must preserve the exact retired bytes");
}
async fn assert_generic_deletes_preserve_source(fixture: &Fixture, slot: usize) {
let before = exact_tree(&source_root(fixture, slot));
let disk = &fixture.disks[slot];
@@ -1578,7 +1578,7 @@ impl LocalDisk {
let object_path = self.io_get_object_path(&volume, &object)?;
let directory = object_path.join(proof.publication.final_data_dir.to_string());
let lease = os::acquire_namespace_mutation_lease_with_owner(&directory, Some(metadata_owner)).await;
let sync = super::effective_durability(&volume).syncs_commit_metadata();
let sync = super::effective_durability(&volume).syncs_recovery_protocol_state();
let result = os::run_blocking_namespace_operation_with_sync(lease, sync, move || {
let result = (|| {
let base = &proof.base;
@@ -221,6 +221,22 @@ impl MultipartSourceAdmission {
super::multipart_source_state::validate_source_mutation(&self.source, &self.base, &self.publication_root, self.initial)
.map_err(std::io::Error::other)
}
pub(super) fn validate_part_settlement(&self, transaction: &Path) -> std::io::Result<bool> {
match self.validate() {
Ok(()) => Ok(true),
Err(error) => {
// A cached parent FD can still name the transaction after Abort
// moved its upload to trash. With SourceRW held, an absent
// canonical transaction is already settled. Resolve beneath the
// publication root so aliases and access errors remain failures.
match os::pin_multipart_source_directory(transaction, &self.base, &self.publication_root) {
Err(missing) if missing.kind() == std::io::ErrorKind::NotFound => Ok(false),
_ => Err(error),
}
}
}
}
}
/// The retirement record is native-only, even through raw file RPCs.
@@ -1272,6 +1288,39 @@ mod tests {
assert!(!directory.exists(), "a per-upload safety guard must not strand empty hash directories");
}
#[cfg(unix)]
#[tokio::test]
async fn multipart_source_settlement_admission_distinguishes_absence_from_aliases() {
let (root, disk, info, _) = fixture().await;
let part = format!("upload/{}/part.1", info.data_dir.expect("fixture data directory"));
let transaction = disk
.io_get_object_path(RUSTFS_META_MULTIPART_BUCKET, &crate::disk::part_transaction_path(&part))
.expect("canonical transaction path");
let admission = disk
.multipart_source_admission(RUSTFS_META_MULTIPART_BUCKET, &part, true, false)
.expect("canonical source admission")
.expect("multipart admission");
std::fs::remove_file(root.path().join(RUSTFS_META_MULTIPART_BUCKET).join("upload/xl.meta"))
.expect("retire the source head");
assert!(admission.validate().is_err(), "the closed source must reject mutations");
std::fs::create_dir_all(&transaction).expect("an existing transaction under the closed source");
assert!(
admission.validate_part_settlement(&transaction).is_err(),
"an existing transaction still requires active-source authority"
);
std::fs::remove_dir(&transaction).expect("remove only the fixture transaction");
assert!(
!admission
.validate_part_settlement(&transaction)
.expect("an absent transaction is already settled")
);
std::os::unix::fs::symlink(root.path().join("absent"), &transaction).expect("inject a dangling transaction alias");
assert!(
admission.validate_part_settlement(&transaction).is_err(),
"a dangling alias must retain the source admission failure"
);
}
#[tokio::test]
async fn multipart_source_active_head_cache_populates_and_invalidates_across_part_and_delete_paths() {
use crate::disk::{DiskAPI as _, PartTransactionAction, ReadOptions};
@@ -1733,7 +1733,7 @@ mod tests {
async fn protected_object_aliases(disk: &LocalDisk) -> Vec<(String, String)> {
let object = disk.root.join(RUSTFS_META_BUCKET).join(OBJECT);
let mut aliases = vec![
let aliases = vec![
(format!("{RUSTFS_META_BUCKET}/."), OBJECT.to_string()),
(format!("{RUSTFS_META_BUCKET}/"), OBJECT.to_string()),
(format!("{RUSTFS_META_BUCKET}/{OBJECT}"), String::new()),
@@ -1743,8 +1743,9 @@ mod tests {
(object.to_str().expect("UTF-8 object path").to_string(), String::new()),
];
#[cfg(unix)]
{
let aliases = {
use std::os::unix::fs::MetadataExt;
let mut aliases = aliases;
let head = fs::metadata(object.join(STORAGE_FORMAT_FILE))
.await
.expect("canonical head metadata");
@@ -1761,7 +1762,8 @@ mod tests {
aliases.push((volume, path));
}
}
}
aliases
};
aliases
}
@@ -0,0 +1,234 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
use crate::runtime::usage_watch::{ScannerUsageWatchRequest, UsageWatchRegistry};
fn watch_request(bucket: &str) -> ScannerUsageWatchRequest {
ScannerUsageWatchRequest {
bucket: bucket.into(),
bucket_incarnation: Uuid::from_u128(2),
watch_id: None,
release: false,
session_id: None,
}
}
async fn fixture() -> (tempfile::TempDir, Arc<LocalDisk>, Arc<UsageWatchRegistry>) {
let root = tempfile::tempdir().expect("watch physical fixture directory");
let endpoint = Endpoint::try_from(root.path().to_string_lossy().as_ref()).expect("watch physical endpoint");
let disk = Arc::new(LocalDisk::new(&endpoint, false).await.expect("watch physical disk"));
disk.make_volume("bucket").await.expect("watch test bucket");
let registry = Arc::new(UsageWatchRegistry::default());
disk.usage_watch_binding.bind(&registry);
(root, disk, registry)
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn usage_watch_stays_inflight_after_metadata_is_visible_and_waiter_is_canceled() {
let (_root, disk, registry) = fixture().await;
let target = disk
.io_get_object_path("bucket", "object")
.expect("target metadata directory");
let (entered, wait_for_enter) = tokio::sync::oneshot::channel();
let (release, hold) = std::sync::mpsc::channel::<()>();
let _hook = os::prepared_publication_test_hooks::install_at(
os::prepared_publication_test_hooks::Stage::DirFsync,
&target,
move || {
let _ = entered.send(());
let _ = hold.recv();
},
);
let writer_disk = Arc::clone(&disk);
let mut writer = tokio::spawn(async move {
let info =
super::test::test_file_info("object", Uuid::new_v4(), Some(Uuid::new_v4()), Some(Bytes::from_static(b"payload")));
writer_disk.write_metadata("", "bucket", "object", info).await
});
tokio::time::timeout(Duration::from_secs(10), wait_for_enter)
.await
.expect("reach physical fsync barrier")
.expect("barrier entered");
assert!(
target.join(STORAGE_FORMAT_FILE).exists(),
"metadata is already visible at the blocked fsync"
);
let during = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("install during active physical mutation");
assert!(during.inflight > 0, "installation must include pre-existing writes");
writer.abort();
assert!((&mut writer).await.expect_err("cancel logical waiter").is_cancelled());
let canceled = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("watch survives logical cancellation");
assert!(canceled.inflight > 0, "physical tail retains its guard");
drop(release);
let settled = tokio::time::timeout(Duration::from_secs(10), async {
loop {
let observation = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("settlement proof");
if observation.inflight == 0 {
break observation;
}
tokio::task::yield_now().await;
}
})
.await
.expect("physical tail settles");
assert!(settled.revision > during.revision);
assert!(!settled.unchanged_since(&during));
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-12", "assertion_id": "USAGE-12-A03", "status": "PASS",
"evidence": {"inflight_at_install": during.inflight, "inflight_after_waiter_cancel": canceled.inflight, "inflight_after_physical_end": settled.inflight, "revision_at_install": during.revision, "revision_after_physical_end": settled.revision}
})
);
drop(disk);
drop(registry);
let root_path = _root.path().to_path_buf();
drop(_root);
assert!(!root_path.exists());
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-12", "status": "PASS", "fixture_removed": !root_path.exists()})
);
}
#[tokio::test]
async fn usage_watch_status_only_metadata_keeps_maintenance_semantics() {
let (_root, disk, registry) = fixture().await;
let info = super::test::test_file_info("object", Uuid::new_v4(), Some(Uuid::new_v4()), Some(Bytes::from_static(b"payload")));
disk.write_metadata("", "bucket", "object", info.clone())
.await
.expect("initial counted version");
let before = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("idle watch");
let mut status = info.clone();
status.metadata.clear();
rustfs_utils::http::metadata_compat::insert_str(
&mut status.metadata,
rustfs_utils::http::SUFFIX_REPLICATION_STATUS,
"arn=COMPLETED;".into(),
);
disk.update_metadata("bucket", "object", status, &UpdateMetadataOpts::default())
.await
.expect("status-class metadata update");
let after = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("status result watch");
assert!(after.unchanged_since(&before), "replication counters retain maintenance cadence");
let mut next = info;
next.version_id = Some(Uuid::new_v4());
disk.write_metadata("", "bucket", "object", next).await.expect("new version");
let changed = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("new version watch");
assert!(changed.revision > after.revision);
assert_eq!(changed.inflight, 0);
}
#[tokio::test]
async fn usage_watch_raw_live_stream_revokes_coverage_and_internal_staging_does_not() {
let (_root, disk, registry) = fixture().await;
let before = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("idle watch");
disk.usage_watch_binding.mark_uncovered_user_stream(RUSTFS_META_TMP_BUCKET);
assert!(
registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("internal staging stays covered")
.unchanged_since(&before)
);
let _stream = disk.create_file("bucket", "bucket", "raw-file", 0).await;
assert_eq!(registry.observe(Uuid::from_u128(1), &watch_request("bucket")), None);
assert!(!disk.usage_watch_binding.matches(&registry));
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn usage_watch_delete_paths_retains_ownership_through_canceled_trash_rename() {
let (_root, disk, registry) = fixture().await;
let target = disk.io_get_object_path("bucket", "delete-me").expect("delete source");
std::fs::write(&target, b"payload").expect("initial source");
let trash = disk.io_get_bucket_path(RUSTFS_META_TMP_DELETED_BUCKET).expect("trash volume");
std::fs::create_dir_all(&trash).expect("trash directory");
let before = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("initial proof");
let (entered, wait_for_enter) = tokio::sync::oneshot::channel();
let (release, hold) = std::sync::mpsc::channel::<()>();
let _hook =
os::prepared_publication_test_hooks::install_at(os::prepared_publication_test_hooks::Stage::Rename, &target, move || {
let _ = entered.send(());
let _ = hold.recv();
});
let deleting_disk = Arc::clone(&disk);
let mut deleting = tokio::spawn(async move { deleting_disk.delete_paths("bucket", &["delete-me".into()]).await });
tokio::time::timeout(Duration::from_secs(10), wait_for_enter)
.await
.expect("reach raw trash rename")
.expect("rename entered");
deleting.abort();
assert!((&mut deleting).await.expect_err("logical waiter canceled").is_cancelled());
let during = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("active proof");
assert!(during.inflight > 0, "trash syscall owns the watch after waiter cancellation");
assert!(during.revision > before.revision);
drop(release);
let after = tokio::time::timeout(Duration::from_secs(10), async {
loop {
let observation = registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("draining proof");
if observation.inflight == 0 {
break observation;
}
tokio::task::yield_now().await;
}
})
.await
.expect("physical rename settles");
assert!(!target.exists());
assert!(after.revision > during.revision);
assert!(!after.unchanged_since(&before));
}
#[tokio::test]
async fn owned_stale_destination_removal_preserves_file_directory_and_symlink_semantics() {
let (_root, disk, registry) = fixture().await;
let target = disk.io_get_object_path("bucket", "stale").expect("stale destination");
std::fs::write(&target, b"stale-file").expect("stale file");
os::remove_with_owner(&target, disk.usage_watch_binding.owner("bucket", None))
.await
.expect("remove stale file");
assert!(!target.exists());
std::fs::create_dir(&target).expect("stale directory");
os::remove_with_owner(&target, disk.usage_watch_binding.owner("bucket", None))
.await
.expect("remove empty directory");
assert!(!target.exists());
#[cfg(unix)]
{
let referent = disk.io_get_object_path("bucket", "retained").expect("symlink referent");
std::fs::write(&referent, b"retained").expect("retained file");
std::os::unix::fs::symlink(&referent, &target).expect("stale symlink");
os::remove_with_owner(&target, disk.usage_watch_binding.owner("bucket", None))
.await
.expect("remove symlink itself");
assert!(!target.exists());
assert_eq!(std::fs::read(referent).expect("referent remains"), b"retained");
}
assert_eq!(
registry
.observe(Uuid::from_u128(1), &watch_request("bucket"))
.expect("all work drained")
.inflight,
0
);
}
+74 -2
View File
@@ -30,6 +30,7 @@ pub mod local;
pub mod multipart_index;
pub mod multipart_source;
pub mod os;
mod usage_watch;
pub(crate) use io_admission::memory as background_memory;
pub(crate) use io_admission::remote as remote_io_admission;
@@ -58,6 +59,21 @@ pub const BUCKET_META_PREFIX: &str = "buckets";
/// a user bucket of the same name, so bucket deletion must leave it in place.
pub const HEAL_REPLACEMENT_RECOVERY_DIR: &str = "ahm-replacement";
pub const FORMAT_CONFIG_FILE: &str = "format.json";
pub(crate) const FORMAT_BOOTSTRAP_FILE: &str = "format.json.bootstrap";
pub(crate) const FORMAT_BOOTSTRAP_DONE_FILE: &str = "format.json.bootstrap.done";
/// Validate an internal format control filename for atomic publication.
///
/// # Errors
/// Returns [`DiskError::MethodNotAllowed`] for every other path.
pub fn validate_format_control_path(path: &str) -> Result<()> {
if matches!(path, FORMAT_CONFIG_FILE | FORMAT_BOOTSTRAP_FILE) {
Ok(())
} else {
Err(DiskError::MethodNotAllowed)
}
}
/// Per-disk marker present while an erasure-set heal is rebuilding this disk.
/// `LocalDisk::disk_info` reports `healing = true` while the file exists.
pub const HEALING_MARKER_PATH: &str = "healing.bin";
@@ -1170,6 +1186,13 @@ impl DiskAPI for Disk {
}
}
async fn write_format_control(&self, path: &str, data: Bytes) -> Result<()> {
match self {
Disk::Local(local_disk) => local_disk.write_format_control(path, data).await,
Disk::Remote(remote_disk) => remote_disk.write_format_control(path, data).await,
}
}
async fn compare_and_update_file(
&self,
volume: &str,
@@ -1406,6 +1429,16 @@ impl Disk {
}
impl Disk {
/// The progress flag is derived from a verified capability scope.
pub async fn ns_scanner_progress_capability(
&self,
) -> Result<Option<crate::storage_api_contracts::internode::NsScannerCapabilities>> {
match self {
Disk::Local(_) => Ok(None),
Disk::Remote(remote_disk) => remote_disk.ns_scanner_progress_capability().await,
}
}
pub async fn ns_scanner_server_epoch(&self) -> Result<Option<Uuid>> {
match self {
Disk::Local(_) => Ok(None),
@@ -1582,14 +1615,18 @@ pub(crate) async fn new_disk_for_instance(
ep: &Endpoint,
opt: &DiskOption,
) -> Result<DiskStore> {
new_disk_with_health_tracker(
let disk = new_disk_with_health_tracker(
ep,
opt,
None,
#[cfg(feature = "internode-transport")]
Some(_instance),
)
.await
.await?;
if let Disk::Local(wrapper) = disk.as_ref() {
wrapper.get_disk().usage_watch_binding.bind(&_instance.usage_watches);
}
Ok(disk)
}
pub(crate) async fn new_disk_with_health_tracker(
@@ -1905,6 +1942,21 @@ pub trait DiskAPI: Debug + Send + Sync + 'static {
async fn read_multiple(&self, req: ReadMultipleReq) -> Result<Vec<ReadMultipleResp>>;
// CleanAbandonedData
async fn write_all(&self, volume: &str, path: &str, data: Bytes) -> Result<()>;
/// Atomically publish a valid per-drive `FormatV3` control file in the system volume.
/// Deployment, topology and member UUID must agree with existing control records.
/// Pending intents admit equivalent plans, and retired intents reject bootstrap
/// republication. Success requires a durable replacement inode and parent entry.
/// Cancellation can leave the complete plan published. Retries revalidate the
/// plan under the per-disk owner before publishing it durably.
///
/// # Errors
/// Returns [`DiskError::MethodNotAllowed`] for unsupported implementations,
/// paths or retired bootstrap intents, [`DiskError::CorruptedFormat`] for
/// invalid or conflicting plans, and an I/O error when publication or its
/// durability barrier fails.
async fn write_format_control(&self, _path: &str, _data: Bytes) -> Result<()> {
Err(DiskError::MethodNotAllowed)
}
async fn read_all(&self, volume: &str, path: &str) -> Result<Bytes>;
/// Atomically replace or remove a small control file only when its current
/// contents match `expected`. Implementations that cannot provide this
@@ -2860,6 +2912,26 @@ pub fn count_part_not_success(part_errs: &[usize]) -> usize {
#[cfg(test)]
mod tests {
#[test]
fn format_control_paths_are_fixed_system_leaf_names() {
for path in [super::FORMAT_CONFIG_FILE, super::FORMAT_BOOTSTRAP_FILE] {
super::validate_format_control_path(path).expect("allowed format control leaf");
}
for path in [
"",
"../format.json",
"format.json/",
".rustfs.sys/format.json",
"format.json.bootstrap.done",
"pool.bin",
] {
assert!(matches!(
super::validate_format_control_path(path),
Err(super::DiskError::MethodNotAllowed)
));
}
}
use super::*;
#[test]
+26 -30
View File
@@ -3817,20 +3817,6 @@ pub async fn read_dir(path: impl AsRef<Path>, count: i32) -> std::io::Result<Vec
Ok(volumes)
}
#[tracing::instrument(level = "debug", skip_all)]
pub async fn rename_all(
src_file_path: impl AsRef<Path>,
dst_file_path: impl AsRef<Path>,
base_dir: impl AsRef<Path>,
publication_root: &PublicationRoot,
) -> Result<()> {
reliable_rename(src_file_path, dst_file_path.as_ref(), base_dir, publication_root)
.await
.map_err(to_file_error)?;
Ok(())
}
/// Retain mutation ownership through both metadata publication and its directory
/// barriers, even when the async caller stops waiting after the rename starts.
pub(crate) async fn rename_metadata_and_sync_with_lease(
@@ -3875,6 +3861,19 @@ pub(crate) async fn fsync_dir_with_owner(path: &Path, namespace_owner: Option<Ar
}
}
/// Preserve file, symlink, and empty-directory removal semantics while the
/// actual filesystem executor retains namespace ownership after cancellation.
pub(crate) async fn remove_with_owner(path: impl AsRef<Path>, namespace_owner: Option<Arc<dyn Send + Sync>>) -> io::Result<()> {
let path = path.as_ref().to_path_buf();
let lease = acquire_namespace_mutation_lease_with_owner(&path, namespace_owner).await;
run_blocking_namespace_operation(lease, move || {
#[cfg(all(any(test, feature = "test-util"), not(windows)))]
prepared_publication_test_hooks::run(prepared_publication_test_hooks::Stage::Remove, &path);
super::fs::remove_std(path)
})
.await
}
/// Retain namespace ownership in the actual filesystem executor after timeout.
pub(crate) async fn remove_file_with_owner(
path: impl AsRef<Path>,
@@ -4553,6 +4552,7 @@ pub(crate) mod multipart_source_syscall_failures {
use super::*;
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub(crate) enum Stage {
Read,
Create,
Write,
FileSync,
@@ -4560,7 +4560,7 @@ pub(crate) mod multipart_source_syscall_failures {
}
type Key = (Stage, PathBuf);
struct Failure {
kind: io::ErrorKind,
error: Mutex<Option<io::Error>>,
triggered: std::sync::atomic::AtomicUsize,
}
static FAILURES: LazyLock<Mutex<HashMap<Key, Arc<Failure>>>> = LazyLock::new(|| Mutex::new(HashMap::new()));
@@ -4585,9 +4585,12 @@ pub(crate) mod multipart_source_syscall_failures {
}
}
pub(crate) fn fail_once(stage: Stage, path: &Path, kind: io::ErrorKind) -> FailureGuard {
fail_once_with_error(stage, path, io::Error::new(kind, "injected native physical syscall failure"))
}
pub(crate) fn fail_once_with_error(stage: Stage, path: &Path, error: io::Error) -> FailureGuard {
let key = (stage, path.to_path_buf());
let failure = Arc::new(Failure {
kind,
error: Mutex::new(Some(error)),
triggered: std::sync::atomic::AtomicUsize::new(0),
});
assert!(
@@ -4599,7 +4602,7 @@ pub(crate) mod multipart_source_syscall_failures {
pub(crate) fn check(stage: Stage, path: &Path) -> io::Result<()> {
if let Some(failure) = FAILURES.lock().remove(&(stage, path.to_path_buf())) {
failure.triggered.fetch_add(1, std::sync::atomic::Ordering::Release);
return Err(io::Error::new(failure.kind, "injected native physical syscall failure"));
return Err(failure.error.lock().take().expect("one-shot physical fault owns its error"));
}
Ok(())
}
@@ -4962,15 +4965,6 @@ pub(crate) fn rename_source_is_missing(src_file_path: &Path, _publication_root:
matches!(std::fs::symlink_metadata(src_file_path), Err(err) if err.kind() == io::ErrorKind::NotFound)
}
async fn reliable_rename(
src_file_path: impl AsRef<Path>,
dst_file_path: impl AsRef<Path>,
base_dir: impl AsRef<Path>,
publication_root: &PublicationRoot,
) -> io::Result<()> {
reliable_rename_inner(src_file_path, dst_file_path, base_dir, publication_root, true).await
}
async fn reliable_rename_inner(
src_file_path: impl AsRef<Path>,
dst_file_path: impl AsRef<Path>,
@@ -8076,6 +8070,8 @@ pub(crate) fn read_multipart_source_metadata_in_pinned(
base: &Path,
publication_root: &PublicationRoot,
) -> io::Result<Vec<u8>> {
#[cfg(test)]
multipart_source_syscall_failures::check(multipart_source_syscall_failures::Stage::Read, &parent.join(name))?;
read_multipart_metadata_in_pinned(pinned, parent, name, base, publication_root, Some(16 * 1024 * 1024))
}
@@ -9165,7 +9161,7 @@ mod tests {
let dst_file_path = dst_file_path.as_ref();
let base_dir = base_dir.as_ref();
let publication_root = test_publication_root(&[src_file_path, dst_file_path, base_dir]);
super::rename_all(src_file_path, dst_file_path, base_dir, &publication_root).await
super::rename_all_with_owner(src_file_path, dst_file_path, base_dir, &publication_root, None).await
}
async fn rename_all_ignore_missing_source(
@@ -10010,7 +10006,7 @@ mod tests {
let configured_dst = configured_base.join("object");
std::fs::create_dir(&configured_base).expect("create bucket through configured root");
std::fs::write(&configured_src, b"configured").expect("write staged object through configured root");
super::rename_all(&configured_src, &configured_dst, &configured_base, &publication_root)
super::rename_all_with_owner(&configured_src, &configured_dst, &configured_base, &publication_root, None)
.await
.expect("publish a configured path relative to the pinned root");
assert_eq!(
@@ -10023,7 +10019,7 @@ mod tests {
let resolved_dst = resolved_base.join("object");
std::fs::create_dir(&resolved_base).expect("create bucket through resolved root");
std::fs::write(&resolved_src, b"resolved").expect("write staged object through resolved root");
super::rename_all(&resolved_src, &resolved_dst, &resolved_base, &publication_root)
super::rename_all_with_owner(&resolved_src, &resolved_dst, &resolved_base, &publication_root, None)
.await
.expect("publish a resolved path relative to the pinned root");
@@ -10443,7 +10439,7 @@ mod tests {
std::fs::write(&dst, b"uncommitted-metadata").expect("write metadata to replace");
let publication_root = PublicationRoot::new(temp_dir.path()).expect("open publication root above the object tree");
super::rename_all(&src, &dst, &object_dir, &publication_root)
super::rename_all_with_owner(&src, &dst, &object_dir, &publication_root, None)
.await
.expect("a rollback source below its destination parent must not conflict with its own guards");
+196
View File
@@ -0,0 +1,196 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
//! Explicit instance binding at the physical disk boundary. Lock order is this
//! binding mutex, then the registry mutex; registry code never locks a disk.
use crate::runtime::usage_watch::{UsageWatchMutationGuard, UsageWatchRegistry};
use std::sync::{Arc, Mutex, Weak};
/// Existing-version replication status writes change neither size nor version
/// membership. Replication aggregates keep their existing maintenance cadence.
pub(crate) fn status_only_metadata_update(fi: &rustfs_filemeta::FileInfo, opts: &super::UpdateMetadataOpts) -> bool {
use rustfs_utils::http::*;
!opts.replace_user_metadata
&& opts.transition_reconcile.is_none()
&& !fi.metadata.is_empty()
&& fi.metadata.keys().all(|key| {
strip_internal_prefix_preserving_case(key).is_some_and(|suffix| {
[
SUFFIX_REPLICA_STATUS,
SUFFIX_REPLICA_TIMESTAMP,
SUFFIX_REPLICATION_STATUS,
SUFFIX_REPLICATION_TIMESTAMP,
SUFFIX_REPLICATION_GENERATION,
SUFFIX_REPLICATION_RESET,
SUFFIX_PURGESTATUS,
]
.iter()
.any(|known| suffix.eq_ignore_ascii_case(known))
})
})
}
#[derive(Default)]
struct BindingState {
registry: Option<Weak<UsageWatchRegistry>>,
unbound_inflight: u64,
prebinding_guard: Option<UsageWatchMutationGuard>,
conflicted: bool,
}
#[derive(Default)]
pub(crate) struct DiskUsageWatchBinding {
state: Mutex<BindingState>,
}
struct UnboundGuard(Arc<DiskUsageWatchBinding>);
impl Drop for UnboundGuard {
fn drop(&mut self) {
let mut state = self.0.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if state.unbound_inflight != 0 {
state.unbound_inflight -= 1;
}
if state.unbound_inflight == 0 {
state.prebinding_guard = None;
}
}
}
impl DiskUsageWatchBinding {
pub(crate) fn mark_uncovered_user_stream(&self, bucket: &str) {
if crate::bucket::utils::is_meta_bucketname(bucket) {
return;
}
let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
state.conflicted = true;
if let Some(registry) = state.registry.as_ref().and_then(Weak::upgrade) {
registry.mark_coverage_unavailable();
}
}
pub(crate) fn bind(&self, registry: &Arc<UsageWatchRegistry>) {
let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if let Some(existing) = state.registry.as_ref().and_then(Weak::upgrade) {
if !Arc::ptr_eq(&existing, registry) {
state.conflicted = true;
// A query may already have checked this binding before
// awaiting disk metadata. Never allow it to reinstall a
// proof after this permanently ambiguous ownership change.
existing.mark_coverage_unavailable();
registry.mark_coverage_unavailable();
}
return;
}
// A newly registered disk can have pre-registration physical tails.
// Keep the whole registry Unknown until those exact guards drain.
if state.unbound_inflight != 0 {
state.prebinding_guard = Some(registry.begin(None));
}
if state.conflicted {
registry.mark_coverage_unavailable();
}
state.registry = Some(Arc::downgrade(registry));
}
pub(crate) fn matches(&self, registry: &Arc<UsageWatchRegistry>) -> bool {
let state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
!state.conflicted
&& state
.registry
.as_ref()
.and_then(Weak::upgrade)
.is_some_and(|bound| Arc::ptr_eq(&bound, registry))
}
pub(crate) fn owner(self: &Arc<Self>, bucket: &str, parent: Option<Arc<dyn Send + Sync>>) -> Option<Arc<dyn Send + Sync>> {
if crate::bucket::utils::is_meta_bucketname(bucket) {
return parent;
}
let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
let guard: Arc<dyn Send + Sync> = if let Some(registry) = state.registry.as_ref().and_then(Weak::upgrade) {
Arc::new(registry.begin((!state.conflicted).then_some(bucket)))
} else {
match state.unbound_inflight.checked_add(1) {
Some(count) => state.unbound_inflight = count,
None => state.conflicted = true,
}
Arc::new(UnboundGuard(Arc::clone(self)))
};
Some(match parent {
Some(parent) => Arc::new((parent, guard)),
None => guard,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runtime::usage_watch::ScannerUsageWatchRequest;
use uuid::Uuid;
#[test]
fn binding_preserves_mutations_that_started_before_registration() {
let binding = Arc::new(DiskUsageWatchBinding::default());
let registry = Arc::new(UsageWatchRegistry::default());
let tail = binding.owner("bucket", None);
binding.bind(&registry);
assert!(binding.matches(&registry));
let request = ScannerUsageWatchRequest {
bucket: "bucket".into(),
bucket_incarnation: Uuid::from_u128(2),
watch_id: None,
release: false,
session_id: None,
};
assert_eq!(registry.observe(Uuid::from_u128(1), &request), None);
drop(tail);
assert_eq!(
registry
.observe(Uuid::from_u128(1), &request)
.expect("drained binding")
.inflight,
0
);
}
#[test]
fn composite_owner_and_instance_conflicts_fail_closed() {
let binding = Arc::new(DiskUsageWatchBinding::default());
let registry = Arc::new(UsageWatchRegistry::default());
binding.bind(&registry);
let request = ScannerUsageWatchRequest {
bucket: "bucket".into(),
bucket_incarnation: Uuid::from_u128(2),
watch_id: None,
release: false,
session_id: None,
};
registry.observe(Uuid::from_u128(1), &request).expect("initial watch");
let owner = binding.owner("bucket", None).expect("physical owner");
let nested = binding.owner("bucket", Some(owner));
assert_eq!(
registry
.observe(Uuid::from_u128(1), &request)
.expect("both operations active")
.inflight,
2
);
drop(nested);
assert_eq!(
registry
.observe(Uuid::from_u128(1), &request)
.expect("drained owners")
.inflight,
0
);
let other = Arc::new(UsageWatchRegistry::default());
binding.bind(&other);
assert!(!binding.matches(&registry));
assert!(!binding.matches(&other));
assert_eq!(registry.observe(Uuid::from_u128(1), &request), None);
assert_eq!(other.observe(Uuid::from_u128(1), &request), None);
}
}
@@ -12,9 +12,9 @@
// See the License for the specific language governing permissions and
// limitations under the License.
// Raw arena memory: the block handle owns a pointer into registered memory
// (see `ArenaBlock::new` for the contract) and implements `BufMut` the way
// `Vec<u8>` does.
// SAFETY: raw arena memory. The block handle owns a pointer into registered
// memory (see `ArenaBlock::new` for the contract) and implements `BufMut` the
// way `Vec<u8>` does.
#![allow(unsafe_code)]
//! Shard buffers for the erasure read path.
@@ -789,6 +789,13 @@ impl BitrotWriter<CustomWriter> {
}
self.write(&buf).await.map(|n| (n, None))
}
pub(crate) fn set_pending_integrity_index(&mut self, idx_file_name: &str, idx_payload: bytes::Bytes) -> bool {
if let Some(local) = self.inner.as_lazy_local_file_writer_mut() {
return local.set_pending_integrity_index(idx_file_name, idx_payload);
}
false
}
}
/// Read into `buf` until it is full or the reader hits EOF, returning the number
@@ -1180,6 +1187,10 @@ impl BitrotWriterWrapper {
self.bitrot_writer.shutdown().await
}
pub(crate) fn set_pending_integrity_index(&mut self, idx_file_name: &str, idx_payload: bytes::Bytes) -> bool {
self.bitrot_writer.set_pending_integrity_index(idx_file_name, idx_payload)
}
/// Extract the inline buffer data, consuming the wrapper
pub fn into_inline_data(self) -> Option<bytes::Bytes> {
match self.writer_type {
+33 -3
View File
@@ -653,6 +653,36 @@ impl<'a> MultiWriter<'a> {
}
}
pub(crate) async fn finish_and_shutdown(&mut self, total: usize) -> std::io::Result<()> {
let mut prewritten = Vec::new();
if let Some(integrity) = self.integrity.as_deref_mut() {
let prepared = integrity.prepare(total).await?;
if let Some(idx_bytes) = prepared.memory_bytes() {
let idx_name = prepared.part.file_name();
prewritten.resize(self.writers.len(), false);
for (index, (writer_opt, err)) in self.writers.iter_mut().zip(self.errs.iter()).enumerate() {
if err.is_none()
&& let Some(writer) = writer_opt.as_mut()
{
prewritten[index] = writer.set_pending_integrity_index(&idx_name, idx_bytes.clone());
}
}
}
}
self.shutdown().await?;
if let Some(integrity) = self.integrity.take()
&& !prewritten.is_empty()
{
for (index, slot) in prewritten.iter_mut().enumerate() {
if self.errs[index].is_some() || self.writers[index].is_none() {
*slot = false;
}
}
integrity.set_prewritten_disks(prewritten);
}
Ok(())
}
pub async fn shutdown(&mut self) -> std::io::Result<()> {
crate::hp_guard!("MultiWriter::shutdown");
let budget = self.next_progress_budget();
@@ -866,7 +896,7 @@ impl Erasure {
let mut mw = MultiWriter::new(writers, write_policy);
mw.integrity = integrity;
mw.write_block(&block).await?;
mw.shutdown().await?;
mw.finish_and_shutdown(total).await?;
Ok((reader, total))
}
@@ -1086,7 +1116,7 @@ impl Erasure {
let (reader, total) = task.join().await??;
let shutdown_stage_start = stage_timer_if_enabled();
writers.shutdown().await?;
writers.finish_and_shutdown(total).await?;
record_internal_stage_if_enabled("erasure_encode_shutdown", shutdown_stage_start);
Ok((reader, total))
}
@@ -1232,7 +1262,7 @@ impl Erasure {
let (reader, total) = task.join().await??;
let shutdown_stage_start = stage_timer_if_enabled();
writers.shutdown().await?;
writers.finish_and_shutdown(total).await?;
record_internal_stage_if_enabled("erasure_encode_batched_shutdown", shutdown_stage_start);
Ok((reader, total))
}
@@ -40,6 +40,7 @@ pub(crate) struct IntegrityBuilder {
part: PartIntegrity,
rows: Vec<u8>,
spill: Option<tokio::fs::File>,
prepared: Option<Box<PreparedIntegrity>>,
}
impl IntegrityBuilder {
@@ -48,6 +49,7 @@ impl IntegrityBuilder {
part: PartIntegrity::new(layout, number).map_err(|_| corrupt())?,
rows: Vec::new(),
spill: None,
prepared: None,
})
}
@@ -100,28 +102,47 @@ impl IntegrityBuilder {
Ok(())
}
async fn into_spool(self) -> io::Result<Spool> {
if let Some(mut file) = self.spill {
file.write_all(&self.rows).await?;
async fn take_spool(&mut self) -> io::Result<Spool> {
let rows = std::mem::take(&mut self.rows);
if let Some(mut file) = self.spill.take() {
file.write_all(&rows).await?;
file.flush().await?;
Ok(Spool::File(file.into_std().await))
} else {
Ok(Spool::Memory(self.rows))
Ok(Spool::Memory(rows))
}
}
pub(crate) async fn prepare(&mut self, size: usize) -> io::Result<&mut PreparedIntegrity> {
if self.prepared.is_none() {
self.part.size = size.try_into().map_err(|_| corrupt())?;
self.part.validate().map_err(|_| corrupt())?;
let part = self.part.clone();
let rows = self.take_spool().await?;
let prepared = if part.stripes < 16 {
build_index(part, rows)?
} else {
tokio::task::spawn_blocking(move || build_index(part, rows))
.await
.map_err(io::Error::other)??
};
self.prepared = Some(Box::new(prepared));
}
self.prepared.as_deref_mut().ok_or_else(corrupt)
}
pub(crate) fn set_prewritten_disks(&mut self, prewritten_disks: Vec<bool>) {
if let Some(prepared) = self.prepared.as_deref_mut() {
prepared.set_prewritten_disks(prewritten_disks);
}
}
pub(crate) async fn finish(mut self, size: usize) -> io::Result<PreparedIntegrity> {
self.part.size = size.try_into().map_err(|_| corrupt())?;
self.part.validate().map_err(|_| corrupt())?;
let part = self.part.clone();
let rows = self.into_spool().await?;
if part.stripes < 16 {
build_index(part, rows)
} else {
tokio::task::spawn_blocking(move || build_index(part, rows))
.await
.map_err(io::Error::other)?
if let Some(prepared) = self.prepared {
return Ok(*prepared);
}
self.prepare(size).await?;
self.prepared.map(|p| *p).ok_or_else(corrupt)
}
}
@@ -213,12 +234,17 @@ fn build_index(mut part: PartIntegrity, mut rows: Spool) -> io::Result<PreparedI
position >>= 1;
}
}
Ok(PreparedIntegrity { part, index })
Ok(PreparedIntegrity {
part,
index,
prewritten_disks: Vec::new(),
})
}
pub(crate) struct PreparedIntegrity {
pub(crate) part: PartIntegrity,
index: Spool,
prewritten_disks: Vec<bool>,
}
impl PreparedIntegrity {
@@ -227,16 +253,30 @@ impl PreparedIntegrity {
part: proof.part.clone(),
rows: proof.part.index_header().to_vec(),
spill: None,
prepared: None,
};
for stripe in 0..proof.part.stripes {
builder.append(&proof.record(stripe).await?).await?;
}
let index = builder.into_spool().await?;
let index = builder.take_spool().await?;
Ok(Self {
part: proof.part.clone(),
index,
prewritten_disks: Vec::new(),
})
}
pub(crate) fn memory_bytes(&self) -> Option<Bytes> {
match &self.index {
Spool::Memory(bytes) => Some(Bytes::copy_from_slice(bytes)),
Spool::File(_) => None,
}
}
pub(crate) fn set_prewritten_disks(&mut self, prewritten_disks: Vec<bool>) {
self.prewritten_disks = prewritten_disks;
}
pub(crate) fn inline_bytes(&self) -> io::Result<Bytes> {
match &self.index {
Spool::Memory(bytes) if bytes.len() <= MAX_INLINE_PROOF_BYTES => Ok(Bytes::copy_from_slice(bytes)),
@@ -267,11 +307,23 @@ impl PreparedIntegrity {
let path = format!("{directory}/{}", self.part.file_name());
let mut file = match self.index {
Spool::Memory(bytes) => {
if disks
.iter()
.enumerate()
.all(|(idx, disk)| disk.is_none() || self.prewritten_disks.get(idx).copied().unwrap_or(false))
{
return Ok(self.part);
}
let payload = Bytes::from(bytes);
futures::future::join_all(disks.iter_mut().map(|disk_opt| {
let prewritten_disks = &self.prewritten_disks;
futures::future::join_all(disks.iter_mut().enumerate().map(|(idx, disk_opt)| {
let path = &path;
let payload = payload.clone();
let already_written = prewritten_disks.get(idx).copied().unwrap_or(false);
async move {
if already_written {
return;
}
let Some(disk) = disk_opt.as_ref() else {
return;
};
+2
View File
@@ -101,6 +101,7 @@ pub(crate) fn legacy_encrypted_range_seek_enabled() -> bool {
mod body_cache_hook;
mod encryption;
mod hook_slot;
mod multipart_completion_binding;
mod object_mutation_hook;
mod read_condition;
mod readers;
@@ -126,6 +127,7 @@ pub use encryption::{
EncryptionResolutionError, EncryptionResolutionErrorKind, ObjectEncryptionResolver, ReadEncryptionMaterial,
ReadEncryptionMode, ReadEncryptionRequest,
};
pub use multipart_completion_binding::MultipartCompletionBinding;
pub(crate) use object_mutation_hook::notify_object_mutation;
pub use object_mutation_hook::{ObjectMutationHook, register_object_mutation_hook, unregister_object_mutation_hook};
pub use readers::*;
@@ -0,0 +1,79 @@
// Copyright 2026 RustFS Team
// SPDX-License-Identifier: Apache-2.0
//! Read-only upload ownership evidence for completion callers, not publication authority.
//! ECStore supplies validated records; completion still rechecks its locked storage state.
use crate::storage_api_contracts::multipart::MultipartInfo;
/// A storage observation of the namespace belonging to an upload.
///
/// This does not reserve an upload or authorize publication. Abort, completion,
/// bucket recreation, and replacement can invalidate it before completion runs.
#[derive(Clone)]
pub struct MultipartCompletionBinding {
bucket: String,
object: String,
active_info: Option<MultipartInfo>,
}
impl MultipartCompletionBinding {
pub(crate) fn active(info: MultipartInfo) -> Self {
Self {
bucket: info.bucket.clone(),
object: info.object.clone(),
active_info: Some(info),
}
}
pub(crate) fn recorded(bucket: &str, object: &str) -> Self {
Self {
bucket: bucket.to_owned(),
object: rustfs_utils::path::decode_dir_object(object),
active_info: None,
}
}
/// The bucket identified by the storage observation.
pub fn bucket(&self) -> &str {
&self.bucket
}
/// The decoded object key identified by the storage observation.
pub fn object(&self) -> &str {
&self.object
}
/// Metadata from an ordinary active lookup, when that lookup succeeded.
/// Completed and retained records never supply active preflight metadata.
pub fn active_info(&self) -> Option<&MultipartInfo> {
self.active_info.as_ref()
}
}
impl std::fmt::Debug for MultipartCompletionBinding {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter
.debug_struct("MultipartCompletionBinding")
.field("bucket", &self.bucket)
.field("object", &self.object)
.field("has_active_info", &self.active_info.is_some())
.finish()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn completion_binding_debug_excludes_preflight_metadata() {
let binding = MultipartCompletionBinding::active(MultipartInfo {
user_defined: [("test-marker".to_owned(), "private-preflight-sentinel".to_owned())].into(),
..Default::default()
});
let debug = format!("{binding:?}");
assert!(!debug.contains("private-preflight-sentinel"));
assert!(debug.contains("has_active_info: true"));
}
}
+13
View File
@@ -99,6 +99,7 @@ pub(crate) struct ScannerPublicationLeaseEntry {
pub(crate) struct NamespaceCommitGuard {
ctx: Arc<InstanceContext>,
counted: bool,
_usage_watch: super::usage_watch::UsageWatchMutationGuard,
}
impl Drop for NamespaceCommitGuard {
@@ -371,6 +372,7 @@ pub struct InstanceContext {
scanner_publication_state: AtomicU8,
namespace_commits: AtomicU64,
namespace_commit_generation: AtomicU64,
pub(crate) usage_watches: Arc<super::usage_watch::UsageWatchRegistry>,
/// Resolves object-encryption material at the application boundary.
object_encryption_resolver: OnceLock<Arc<dyn ObjectEncryptionResolver>>,
delete_recovery_hints: DeleteRecoveryHints,
@@ -496,6 +498,7 @@ impl InstanceContext {
scanner_publication_state: AtomicU8::new(SCANNER_PUBLICATION_STATE_UNKNOWN),
namespace_commits: AtomicU64::new(0),
namespace_commit_generation: AtomicU64::new(0),
usage_watches: Arc::new(super::usage_watch::UsageWatchRegistry::default()),
object_encryption_resolver: OnceLock::new(),
delete_recovery_hints: DeleteRecoveryHints::default(),
tier_delete_journal_recovery_stores: std::sync::Mutex::new(HashSet::new()),
@@ -735,6 +738,15 @@ impl InstanceContext {
}
pub(crate) fn begin_namespace_commit(self: &Arc<Self>) -> Arc<NamespaceCommitGuard> {
self.begin_namespace_commit_scoped(None)
}
pub(crate) fn begin_namespace_commit_for_bucket(self: &Arc<Self>, bucket: &str) -> Arc<NamespaceCommitGuard> {
self.begin_namespace_commit_scoped(Some(bucket))
}
fn begin_namespace_commit_scoped(self: &Arc<Self>, bucket: Option<&str>) -> Arc<NamespaceCommitGuard> {
let usage_watch = self.usage_watches.begin(bucket);
let counted = self
.namespace_commits
.try_update(Ordering::AcqRel, Ordering::Acquire, |count| count.checked_add(1))
@@ -747,6 +759,7 @@ impl InstanceContext {
Arc::new(NamespaceCommitGuard {
ctx: Arc::clone(self),
counted,
_usage_watch: usage_watch,
})
}
+1
View File
@@ -17,3 +17,4 @@
pub(crate) mod global;
pub(crate) mod instance;
pub(crate) mod sources;
pub(crate) mod usage_watch;
+4
View File
@@ -525,6 +525,9 @@ pub(crate) async fn record_local_disks(instance_ctx: &Arc<InstanceContext>, disk
let map = instance_ctx.local_disk_map();
let mut global_local_disk_map = map.write().await;
for disk in disks {
if let crate::disk::Disk::Local(wrapper) = disk.as_ref() {
wrapper.get_disk().usage_watch_binding.bind(&instance_ctx.usage_watches);
}
let path = disk.endpoint().to_string();
global_local_disk_map.insert(path, Some(disk));
}
@@ -611,6 +614,7 @@ pub(crate) async fn initialize_local_disk_maps(
Err(err) => return Err(err.into()),
};
if let crate::disk::Disk::Local(wrapper) = disk.as_ref() {
wrapper.get_disk().usage_watch_binding.bind(&instance_ctx.usage_watches);
wrapper.get_disk().bind_multipart_proof_authority(&multipart_authority)?;
}
let path = disk.endpoint().to_string();
+334
View File
@@ -0,0 +1,334 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
//! Bounded, same-session bucket mutation watches. The registry lock is a short
//! synchronous critical section shared by installation, mutation begin/end,
//! and observation. No I/O or await occurs while it is held.
use std::{
collections::HashMap,
sync::{Arc, Mutex},
time::{Duration, Instant},
};
use uuid::Uuid;
pub const SCANNER_USAGE_WATCH_COVERAGE_VERSION: u32 = rustfs_protos::usage_watch::USAGE_WATCH_COVERAGE_VERSION;
pub const SCANNER_USAGE_WATCH_MAX_ENTRIES: usize = 256;
pub const SCANNER_USAGE_WATCH_MAX_ACTIVE_BUCKETS: usize = 4096;
pub const SCANNER_USAGE_WATCH_MAX_NAME_BYTES: usize = 16 * 1024;
pub const SCANNER_USAGE_WATCH_MAX_ACTIVE_NAME_BYTES: usize = 256 * 1024;
pub const SCANNER_USAGE_WATCH_LEASE_MS: u64 = rustfs_protos::usage_watch::USAGE_WATCH_MAX_LEASE_MS;
/// A missing watch ID installs a new watch; a supplied ID can only refresh the
/// exact, still-live token. An expired token never silently creates a new one.
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ScannerUsageWatchRequest {
pub bucket: String,
pub bucket_incarnation: Uuid,
pub watch_id: Option<Uuid>,
/// Release only this exact producer session and token after publication.
pub release: bool,
pub session_id: Option<Uuid>,
}
#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct ScannerUsageWatchKnown {
pub owner_id: Uuid,
pub session_id: Uuid,
pub watch_id: Uuid,
pub bucket_incarnation: Uuid,
pub revision: u64,
pub inflight: u64,
pub coverage_version: u32,
pub coverage_epoch: u64,
/// Duration from the receiver's observation, never a wall-clock deadline.
pub lease_remaining_ms: u64,
}
impl ScannerUsageWatchKnown {
pub fn is_well_formed(&self) -> bool {
!self.owner_id.is_nil()
&& !self.session_id.is_nil()
&& !self.watch_id.is_nil()
&& !self.bucket_incarnation.is_nil()
&& self.revision != 0
&& self.revision != u64::MAX
&& self.inflight != u64::MAX
&& self.coverage_version == SCANNER_USAGE_WATCH_COVERAGE_VERSION
&& self.coverage_epoch != 0
&& self.coverage_epoch != u64::MAX
&& self.lease_remaining_ms != 0
&& self.lease_remaining_ms <= SCANNER_USAGE_WATCH_LEASE_MS
}
/// Equality of stable proof fields; the caller must also respect its
/// conservative local lease deadline and validate the source/owner set.
pub fn unchanged_since(&self, earlier: &Self) -> bool {
self.is_well_formed()
&& earlier.is_well_formed()
&& self.owner_id == earlier.owner_id
&& self.session_id == earlier.session_id
&& self.watch_id == earlier.watch_id
&& self.bucket_incarnation == earlier.bucket_incarnation
&& self.revision == earlier.revision
&& self.inflight == 0
&& earlier.inflight == 0
&& self.coverage_version == SCANNER_USAGE_WATCH_COVERAGE_VERSION
&& self.coverage_version == earlier.coverage_version
&& self.coverage_epoch == earlier.coverage_epoch
&& self.lease_remaining_ms != 0
&& earlier.lease_remaining_ms != 0
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ScannerUsageWatchObservation {
pub bucket: String,
/// Missing means Unknown. It is never a revision-zero clean value.
pub known: Option<ScannerUsageWatchKnown>,
}
struct Watch {
owner: Uuid,
token: Uuid,
incarnation: Uuid,
revision: u64,
expires_at: Instant,
}
#[derive(Default)]
struct State {
watches: HashMap<Arc<str>, Watch>,
active: HashMap<Arc<str>, u64>,
watch_name_bytes: usize,
active_name_bytes: usize,
untracked: u64,
exhausted: bool,
coverage_epoch: u64,
}
pub(crate) struct UsageWatchRegistry {
session: Uuid,
state: Mutex<State>,
}
enum Mutation {
Tracked(Arc<str>),
Untracked,
}
/// The physical mutation owner retains this value through all detached tails.
pub(crate) struct UsageWatchMutationGuard {
registry: Arc<UsageWatchRegistry>,
mutation: Mutation,
}
impl Default for UsageWatchRegistry {
fn default() -> Self {
Self {
session: Uuid::new_v4(),
state: Mutex::new(State {
coverage_epoch: 1,
..Default::default()
}),
}
}
}
impl State {
fn invalidate_all(&mut self) {
self.watches.clear();
self.watch_name_bytes = 0;
match self.coverage_epoch.checked_add(1).filter(|epoch| *epoch != u64::MAX) {
Some(epoch) => self.coverage_epoch = epoch,
None => self.exhausted = true,
}
}
fn advance_bucket(&mut self, bucket: &str) {
if let Some(watch) = self.watches.get_mut(bucket) {
if let Some(next) = watch.revision.checked_add(1).filter(|next| *next != u64::MAX) {
watch.revision = next;
} else {
self.remove_watch(bucket);
}
}
}
fn remove_watch(&mut self, bucket: &str) {
if let Some((name, _)) = self.watches.remove_entry(bucket) {
self.watch_name_bytes -= name.len();
}
}
}
impl UsageWatchRegistry {
pub(crate) fn session_id(&self) -> Uuid {
self.session
}
pub(crate) fn begin(self: &Arc<Self>, bucket: Option<&str>) -> UsageWatchMutationGuard {
let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
// Internal metadata is outside the user bucket counters. Callers with
// an unknown user scope must pass None, which invalidates every watch.
let bucket = bucket.filter(|bucket| !bucket.is_empty() && bucket.len() <= 63);
let tracked = bucket.and_then(|bucket| {
if let Some((key, count)) = state.active.get_key_value(bucket) {
let key = Arc::clone(key);
let next = count.checked_add(1)?;
state.active.insert(Arc::clone(&key), next);
return Some(key);
}
if state.active.len() >= SCANNER_USAGE_WATCH_MAX_ACTIVE_BUCKETS
|| state.active_name_bytes + bucket.len() > SCANNER_USAGE_WATCH_MAX_ACTIVE_NAME_BYTES
{
return None;
}
let key: Arc<str> = Arc::from(bucket);
state.active_name_bytes += bucket.len();
state.active.insert(Arc::clone(&key), 1);
Some(key)
});
let mutation = match tracked {
Some(bucket) => {
state.advance_bucket(&bucket);
Mutation::Tracked(bucket)
}
None => {
state.invalidate_all();
match state.untracked.checked_add(1) {
Some(count) => state.untracked = count,
None => state.exhausted = true,
}
Mutation::Untracked
}
};
UsageWatchMutationGuard {
registry: Arc::clone(self),
mutation,
}
}
/// Replay and unsupported runtime mode transitions revoke tokens. They
/// never copy a durable generation into a same-session watch revision.
pub(crate) fn invalidate(&self) {
self.state
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.invalidate_all();
}
/// A write mode without a physical completion owner cannot establish
/// same-session coverage again. Keep the global fallback until restart.
pub(crate) fn mark_coverage_unavailable(&self) {
let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
state.exhausted = true;
state.invalidate_all();
}
pub(crate) fn observe(&self, owner: Uuid, request: &ScannerUsageWatchRequest) -> Option<ScannerUsageWatchKnown> {
self.observe_at(owner, request, Instant::now())
}
fn observe_at(&self, owner: Uuid, request: &ScannerUsageWatchRequest, now: Instant) -> Option<ScannerUsageWatchKnown> {
if owner.is_nil() || request.bucket_incarnation.is_nil() || request.bucket.is_empty() || request.bucket.len() > 63 {
return None;
}
let mut state = self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if request.release {
if request.session_id == Some(self.session)
&& state.watches.get(request.bucket.as_str()).is_some_and(|watch| {
watch.owner == owner
&& watch.incarnation == request.bucket_incarnation
&& request.watch_id == Some(watch.token)
})
{
state.remove_watch(&request.bucket);
}
// Release is resource retirement, never an assertion of cleanliness.
return None;
}
if request.session_id.is_some_and(|session| session != self.session) {
return None;
}
if state.exhausted || state.untracked != 0 {
return None;
}
// Sweeps are bounded by the fixed watch limit. Never accumulate tombstones.
state.watches.retain(|_, watch| watch.expires_at > now);
state.watch_name_bytes = state.watches.keys().map(|key| key.len()).sum();
let matches = state.watches.get(request.bucket.as_str()).is_some_and(|watch| {
watch.owner == owner
&& watch.incarnation == request.bucket_incarnation
&& request.watch_id.is_none_or(|id| id == watch.token)
});
if !matches {
if request.watch_id.is_some() {
return None;
}
state.remove_watch(&request.bucket);
if state.watches.len() >= SCANNER_USAGE_WATCH_MAX_ENTRIES
|| state.watch_name_bytes + request.bucket.len() > SCANNER_USAGE_WATCH_MAX_NAME_BYTES
{
return None;
}
let key: Arc<str> = Arc::from(request.bucket.as_str());
state.watch_name_bytes += key.len();
state.watches.insert(
key,
Watch {
owner,
token: Uuid::new_v4(),
incarnation: request.bucket_incarnation,
revision: 1,
expires_at: now + Duration::from_millis(SCANNER_USAGE_WATCH_LEASE_MS),
},
);
}
let inflight = state.active.get(request.bucket.as_str()).copied().unwrap_or(0);
let coverage_epoch = state.coverage_epoch;
let watch = state.watches.get_mut(request.bucket.as_str())?;
watch.expires_at = now + Duration::from_millis(SCANNER_USAGE_WATCH_LEASE_MS);
Some(ScannerUsageWatchKnown {
owner_id: owner,
session_id: self.session,
watch_id: watch.token,
bucket_incarnation: watch.incarnation,
revision: watch.revision,
inflight,
coverage_version: SCANNER_USAGE_WATCH_COVERAGE_VERSION,
coverage_epoch,
lease_remaining_ms: SCANNER_USAGE_WATCH_LEASE_MS,
})
}
}
impl Drop for UsageWatchMutationGuard {
fn drop(&mut self) {
let mut state = self.registry.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
match &self.mutation {
Mutation::Tracked(bucket) => {
// Advance before exposing inflight=0, including canceled and
// failed operations whose physical outcome may be uncertain.
state.advance_bucket(bucket);
if let Some(count) = state.active.get_mut(bucket) {
*count -= 1;
if *count == 0 {
state.active.remove(bucket);
state.active_name_bytes -= bucket.len();
}
} else {
state.exhausted = true;
state.invalidate_all();
}
}
Mutation::Untracked => {
if state.untracked != 0 {
state.untracked -= 1;
}
}
}
}
}
#[cfg(test)]
mod tests;
@@ -0,0 +1,321 @@
// Copyright 2026 RustFS Team
// Licensed under the Apache License, Version 2.0.
use super::*;
fn request(bucket: &str) -> ScannerUsageWatchRequest {
ScannerUsageWatchRequest {
bucket: bucket.into(),
bucket_incarnation: Uuid::from_u128(7),
watch_id: None,
release: false,
session_id: None,
}
}
fn query(registry: &UsageWatchRegistry, request: &ScannerUsageWatchRequest, at: Instant) -> ScannerUsageWatchKnown {
registry
.observe_at(Uuid::from_u128(1), request, at)
.expect("known bucket proof")
}
#[test]
fn watch_installation_detects_an_already_active_mutation() {
let registry = Arc::new(UsageWatchRegistry::default());
let now = Instant::now();
let mutation = registry.begin(Some("bucket"));
let before = query(&registry, &request("bucket"), now);
assert_eq!(before.inflight, 1);
drop(mutation);
let after = query(&registry, &request("bucket"), now);
assert_eq!(after.inflight, 0);
assert!(after.revision > before.revision);
assert!(!after.unchanged_since(&before));
}
#[test]
fn every_begin_and_physical_tail_end_advances_only_the_target_bucket() {
let registry = Arc::new(UsageWatchRegistry::default());
let now = Instant::now();
let before = query(&registry, &request("cold"), now);
let hot = registry.begin(Some("hot"));
assert!(query(&registry, &request("cold"), now).unchanged_since(&before));
drop(hot);
assert!(query(&registry, &request("cold"), now).unchanged_since(&before));
let owner = Arc::new(registry.begin(Some("cold")));
let physical_tail = Arc::clone(&owner);
let during = query(&registry, &request("cold"), now);
assert_eq!(during.revision, before.revision + 1);
assert_eq!(during.inflight, 1);
drop(owner);
assert_eq!(query(&registry, &request("cold"), now).inflight, 1);
drop(physical_tail);
let after = query(&registry, &request("cold"), now);
assert_eq!(after.revision, before.revision + 2);
assert_eq!(after.inflight, 0);
}
#[test]
fn expiry_reincarnation_and_restart_do_not_resurrect_old_tokens() {
let registry = UsageWatchRegistry::default();
let now = Instant::now();
let before = query(&registry, &request("bucket"), now);
let mut refresh = request("bucket");
refresh.watch_id = Some(before.watch_id);
let expired = now + Duration::from_millis(SCANNER_USAGE_WATCH_LEASE_MS);
assert_eq!(registry.observe_at(Uuid::from_u128(1), &refresh, expired), None);
let after = query(&registry, &request("bucket"), expired);
assert_ne!(after.watch_id, before.watch_id);
assert!(!after.unchanged_since(&before));
refresh.bucket_incarnation = Uuid::new_v4();
assert_eq!(registry.observe_at(Uuid::from_u128(1), &refresh, expired), None);
refresh.watch_id = None;
let recreated = query(&registry, &refresh, expired);
assert_ne!(recreated.watch_id, after.watch_id);
let restarted = UsageWatchRegistry::default();
let restart_proof = query(&restarted, &refresh, expired);
assert!(!restart_proof.unchanged_since(&recreated));
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-12", "assertion_id": "USAGE-12-A05", "status": "PASS",
"evidence": {"expired_token": before.watch_id, "replacement_token": after.watch_id, "lease_ms": SCANNER_USAGE_WATCH_LEASE_MS, "expired_proof_accepted": false}
})
);
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-12", "assertion_id": "USAGE-12-A06", "status": "PASS",
"evidence": {"previous_session": recreated.session_id, "new_session": restart_proof.session_id, "unchanged": restart_proof.unchanged_since(&recreated)}
})
);
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-12", "status": "PASS", "scope": "process-local"})
);
}
#[test]
fn watch_capacity_is_bounded_and_rejected_entries_are_unknown() {
let registry = UsageWatchRegistry::default();
let now = Instant::now();
for index in 0..SCANNER_USAGE_WATCH_MAX_ENTRIES {
query(&registry, &request(&format!("bucket-{index}")), now);
}
assert_eq!(registry.observe_at(Uuid::from_u128(1), &request("overflow"), now), None);
let state = registry.state.lock().expect("registry state");
assert_eq!(state.watches.len(), SCANNER_USAGE_WATCH_MAX_ENTRIES);
assert!(state.watch_name_bytes <= SCANNER_USAGE_WATCH_MAX_NAME_BYTES);
}
#[test]
fn active_mutation_overflow_revokes_all_proofs_until_untracked_work_ends() {
let registry = Arc::new(UsageWatchRegistry::default());
let now = Instant::now();
let old = query(&registry, &request("cold"), now);
let mut active = Vec::new();
for index in 0..SCANNER_USAGE_WATCH_MAX_ACTIVE_BUCKETS {
active.push(registry.begin(Some(&format!("active-{index}"))));
}
let overflow = registry.begin(Some("not-in-active-map"));
assert_eq!(registry.observe_at(Uuid::from_u128(1), &request("cold"), now), None);
{
let state = registry.state.lock().expect("registry state");
assert_eq!(state.active.len(), SCANNER_USAGE_WATCH_MAX_ACTIVE_BUCKETS);
assert!(state.active_name_bytes <= SCANNER_USAGE_WATCH_MAX_ACTIVE_NAME_BYTES);
}
drop(overflow);
let new = query(&registry, &request("cold"), now);
assert_ne!(new.watch_id, old.watch_id);
assert!(new.coverage_epoch > old.coverage_epoch);
drop(active);
println!(
"usage_assertion: {}",
serde_json::json!({
"case_id": "USAGE-12", "assertion_id": "USAGE-12-A04", "status": "PASS",
"evidence": {"active_capacity": SCANNER_USAGE_WATCH_MAX_ACTIVE_BUCKETS, "previous_token": old.watch_id, "replacement_token": new.watch_id, "previous_coverage": old.coverage_epoch, "new_coverage": new.coverage_epoch, "active_after_cleanup": registry.state.lock().expect("drained registry").active.len()}
})
);
println!(
"usage_cleanup: {}",
serde_json::json!({"case_id": "USAGE-12", "status": "PASS", "scope": "process-local"})
);
}
#[test]
fn unknown_scope_and_replay_invalidate_without_reusing_generation() {
let registry = Arc::new(UsageWatchRegistry::default());
let now = Instant::now();
let old = query(&registry, &request("bucket"), now);
let mutation = registry.begin(None);
assert_eq!(registry.observe_at(Uuid::from_u128(1), &request("bucket"), now), None);
drop(mutation);
let new = query(&registry, &request("bucket"), now);
assert_ne!(new.watch_id, old.watch_id);
registry.invalidate();
let replayed = query(&registry, &request("bucket"), now);
assert_ne!(replayed.watch_id, new.watch_id);
assert!(replayed.coverage_epoch > new.coverage_epoch);
}
#[test]
fn revision_exhaustion_invalidates_the_token_without_aba() {
let registry = Arc::new(UsageWatchRegistry::default());
let now = Instant::now();
let old = query(&registry, &request("bucket"), now);
registry
.state
.lock()
.expect("registry state")
.watches
.get_mut("bucket")
.expect("installed watch")
.revision = u64::MAX - 1;
let mutation = registry.begin(Some("bucket"));
let refresh = ScannerUsageWatchRequest {
watch_id: Some(old.watch_id),
..request("bucket")
};
assert_eq!(registry.observe_at(Uuid::from_u128(1), &refresh, now), None);
let during = query(&registry, &request("bucket"), now);
assert_ne!(during.watch_id, old.watch_id);
assert_eq!(during.inflight, 1);
drop(mutation);
assert_eq!(query(&registry, &request("bucket"), now).revision, during.revision + 1);
}
#[test]
fn coverage_epoch_exhaustion_stays_unknown_without_wrapping() {
let registry = UsageWatchRegistry::default();
let now = Instant::now();
query(&registry, &request("bucket"), now);
registry.state.lock().expect("registry state").coverage_epoch = u64::MAX - 1;
registry.invalidate();
assert_eq!(registry.observe_at(Uuid::from_u128(1), &request("bucket"), now), None);
registry.invalidate();
assert_eq!(registry.observe_at(Uuid::from_u128(1), &request("bucket"), now), None);
let state = registry.state.lock().expect("registry state");
assert!(state.exhausted);
assert!(state.watches.is_empty());
assert_eq!(state.coverage_epoch, u64::MAX - 1);
}
#[test]
fn proof_comparison_rejects_every_changed_identity_and_busy_endpoint() {
let registry = UsageWatchRegistry::default();
let original = query(&registry, &request("bucket"), Instant::now());
for field in 0..10 {
let mut changed = original.clone();
match field {
0 => changed.owner_id = Uuid::new_v4(),
1 => changed.session_id = Uuid::new_v4(),
2 => changed.watch_id = Uuid::new_v4(),
3 => changed.bucket_incarnation = Uuid::new_v4(),
4 => changed.revision += 1,
5 => changed.inflight = 1,
6 => changed.coverage_version += 1,
7 => changed.coverage_epoch += 1,
8 => changed.lease_remaining_ms = 0,
_ => {
changed.revision = 0;
changed.watch_id = Uuid::nil();
}
}
assert!(!changed.unchanged_since(&original));
}
}
#[test]
fn watch_contention_cost_preserves_all_mutation_boundaries() {
let registry = Arc::new(UsageWatchRegistry::default());
let before = query(&registry, &request("hot"), Instant::now());
let threads = 8_u64;
let writes_per_thread = 10_000_u64;
let started = Instant::now();
std::thread::scope(|scope| {
for _ in 0..threads {
let registry = Arc::clone(&registry);
scope.spawn(move || {
for _ in 0..writes_per_thread {
drop(registry.begin(Some("hot")));
}
});
}
});
let elapsed = started.elapsed();
let after = query(&registry, &request("hot"), Instant::now());
let writes = threads * writes_per_thread;
assert_eq!(after.revision, before.revision + 2 * writes);
assert_eq!(after.inflight, 0);
assert!(registry.state.lock().expect("drained registry").active.is_empty());
eprintln!(
"usage_watch_cost threads={threads} writes={writes} elapsed_us={} wall_ns_per_begin_end={}",
elapsed.as_micros(),
elapsed.as_nanos() / u128::from(writes)
);
}
#[test]
fn exact_release_preserves_other_sessions_tokens_and_active_mutations() {
let registry = Arc::new(UsageWatchRegistry::default());
let owner = Uuid::from_u128(1);
let now = Instant::now();
let before = query(&registry, &request("bucket"), now);
let release = ScannerUsageWatchRequest {
watch_id: Some(before.watch_id),
session_id: Some(before.session_id),
release: true,
..request("bucket")
};
for case in 0..5 {
let mut wrong = release.clone();
let mut wrong_owner = owner;
match case {
0 => wrong.watch_id = Some(Uuid::new_v4()),
1 => wrong.session_id = Some(Uuid::new_v4()),
2 => wrong.bucket_incarnation = Uuid::new_v4(),
3 => wrong.watch_id = None,
_ => wrong_owner = Uuid::new_v4(),
}
assert_eq!(registry.observe_at(wrong_owner, &wrong, now), None);
assert!(query(&registry, &request("bucket"), now).unchanged_since(&before));
}
let mutation = registry.begin(Some("bucket"));
assert_eq!(registry.observe_at(owner, &release, now), None);
assert!(registry.state.lock().expect("registry state").watches.is_empty());
let replacement = query(&registry, &request("bucket"), now);
assert_ne!(replacement.watch_id, before.watch_id);
assert_eq!(replacement.inflight, 1, "release cannot discard physical mutation ownership");
assert_eq!(registry.observe_at(owner, &release, now), None);
assert_eq!(query(&registry, &request("bucket"), now).watch_id, replacement.watch_id);
drop(mutation);
let after = query(&registry, &request("bucket"), now);
assert_eq!(after.inflight, 0);
assert!(after.revision > replacement.revision);
}
#[test]
fn completed_watch_release_admits_later_buckets_before_lease_expiry() {
let registry = UsageWatchRegistry::default();
let now = Instant::now();
let mut completed = Vec::new();
for index in 0..SCANNER_USAGE_WATCH_MAX_ENTRIES {
let req = request(&format!("bucket-{index:03}"));
let known = query(&registry, &req, now);
completed.push(ScannerUsageWatchRequest {
watch_id: Some(known.watch_id),
session_id: Some(known.session_id),
release: true,
..req
});
}
assert_eq!(registry.observe_at(Uuid::from_u128(1), &request("later-bucket"), now), None);
for release in completed {
assert_eq!(registry.observe_at(Uuid::from_u128(1), &release, now), None);
}
let state = registry.state.lock().expect("registry state");
assert_eq!(state.watches.len(), 0);
assert_eq!(state.watch_name_bytes, 0);
drop(state);
assert!(query(&registry, &request("later-bucket"), now).is_well_formed());
}
@@ -107,7 +107,7 @@ pub(super) async fn run(
result.state = ItemState::Prepared;
result.detail = None;
etag = checkpoint(api, job, &etag, guard).await?;
let mut file = match stage(api, job, index, &info, &opts, guard).await {
let staged = match verify_source(api, job, index, &info, &opts, guard).await {
Ok(file) => file,
Err(IntegrityError::Conflict) => {
job.results[index].state = ItemState::Stale;
@@ -125,6 +125,7 @@ pub(super) async fn run(
if job.request.mode == JobMode::Audit {
job.results[index].state = ItemState::Verified;
} else {
let mut file = staged.ok_or(IntegrityError::Invalid("missing migration payload"))?;
let snapshot = validate_destination(api, job).await?;
file.rewind().await?;
let raw = sha256_bytes(&expected)?;
@@ -231,30 +232,29 @@ async fn ensure_running(api: &Arc<ECStore>, job: &Job, guard: &rustfs_lock::Name
Ok(())
}
async fn stage(
async fn verify_source(
api: &Arc<ECStore>,
job: &Job,
index: usize,
info: &ObjectInfo,
opts: &ObjectOptions,
guard: &rustfs_lock::NamespaceLockGuard,
) -> Result<tokio::fs::File> {
) -> Result<Option<tokio::fs::File>> {
let mut reader = api
.get_object_reader(&job.bucket, &job.request.items[index].key, None, Default::default(), opts)
.await?;
if fingerprint(&reader.object_info) != fingerprint(info) {
return Err(IntegrityError::Conflict);
}
let std_file = tokio::task::spawn_blocking(tempfile::tempfile)
.await
.map_err(|_| IntegrityError::Invalid("staging task failed"))??;
let mut file = tokio::fs::File::from_std(std_file);
let mut file = staging_file(job.request.mode, tempfile::tempfile).await?;
let expected = job.results[index]
.expected_sha256
.as_deref()
.ok_or(IntegrityError::Invalid("missing expected digest"))?;
copy_verified(api, job, &mut reader.stream, Some(&mut file), info.size, expected, guard).await?;
file.flush().await?;
copy_verified(api, job, &mut reader.stream, file.as_mut(), info.size, expected, guard).await?;
if let Some(file) = file.as_mut() {
file.flush().await?;
}
let after = api.get_object_info(&job.bucket, &job.request.items[index].key, opts).await?;
if fingerprint(&after) != fingerprint(info) {
return Err(IntegrityError::Conflict);
@@ -262,6 +262,20 @@ async fn stage(
Ok(file)
}
async fn staging_file(
mode: JobMode,
create: impl FnOnce() -> std::io::Result<std::fs::File> + Send + 'static,
) -> Result<Option<tokio::fs::File>> {
// Migration must publish the exact bytes verified here. Audit has no second consumer.
if mode == JobMode::Audit {
return Ok(None);
}
let file = tokio::task::spawn_blocking(create)
.await
.map_err(|_| IntegrityError::Invalid("staging task failed"))??;
Ok(Some(tokio::fs::File::from_std(file)))
}
async fn copy_verified(
api: &Arc<ECStore>,
job: &Job,
@@ -466,3 +480,31 @@ impl tokio::io::AsyncRead for ThrottledFile {
}
}
}
#[cfg(test)]
mod staging_tests {
use super::*;
#[tokio::test]
async fn audit_does_not_need_a_writable_payload_staging_volume() {
let result = staging_file(JobMode::Audit, || Err(std::io::Error::other("staging volume full")))
.await
.expect("audit must not open staging storage");
assert!(result.is_none());
}
#[tokio::test]
async fn migration_requires_writable_payload_staging() {
assert!(
staging_file(JobMode::Migrate, || { Err(std::io::Error::other("staging volume full")) })
.await
.is_err()
);
let mut file = staging_file(JobMode::Migrate, tempfile::tempfile).await.unwrap().unwrap();
file.write_all(b"verified bytes").await.unwrap();
file.rewind().await.unwrap();
let mut bytes = Vec::new();
file.read_to_end(&mut bytes).await.unwrap();
assert_eq!(bytes, b"verified bytes");
}
}
@@ -3211,6 +3211,42 @@ impl NotificationSys {
Ok(true)
}
/// Query exactly the requested peers and buckets. Missing peers and old
/// protocol endpoints fail the query instead of fabricating clean entries.
pub async fn scanner_usage_watches(
&self,
requests: Vec<(String, uuid::Uuid, Vec<crate::runtime::usage_watch::ScannerUsageWatchRequest>)>,
) -> Result<Vec<(String, Vec<crate::runtime::usage_watch::ScannerUsageWatchObservation>)>> {
let clients = self
.peer_clients
.iter()
.flatten()
.map(|client| (client.grid_host.clone(), client.clone()))
.collect::<HashMap<_, _>>();
let mut seen = std::collections::HashSet::new();
let mut futures = Vec::with_capacity(requests.len());
for (host, owner, entries) in requests {
if !seen.insert(host.clone()) {
return Err(Error::other("duplicate usage watch peer"));
}
let client = clients
.get(&host)
.cloned()
.ok_or_else(|| Error::other("usage watch peer is not reachable"))?;
futures.push(async move {
let observations = timeout(SCANNER_ACTIVITY_PROBE_TIMEOUT, client.scanner_usage_watch(owner, entries))
.await
.map_err(|_| Error::other("usage watch peer timed out"))??;
Ok::<_, Error>((host, observations))
});
}
let mut results = Vec::with_capacity(futures.len());
for result in join_all(futures).await {
results.push(result?);
}
Ok(results)
}
pub async fn acknowledge_scanner_dirty_usage(&self, acknowledgements: Vec<ScannerDirtyUsageAcknowledgement>) -> Result<bool> {
let mut by_host = HashMap::with_capacity(acknowledgements.len());
for acknowledgement in acknowledgements {
@@ -306,6 +306,7 @@ pub(in crate::set_disk) struct CleanupSourceMetadata {
pub metadata: Vec<rustfs_filemeta::FileInfo>,
pub errors: Vec<Option<DiskError>>,
pub certified_original: Option<rustfs_filemeta::FileInfo>,
pub inspection_error: Option<DiskError>,
}
/// A successful close is useful only to the guarded cleanup caller. Its owned
@@ -478,6 +479,10 @@ pub(in crate::set_disk) async fn cleanup_source_metadata(
bind_multipart_proof_snapshot(disks, authority)?;
let ids = disk_ids(disks).await;
let inspections = cleanup_inspections(disks, path, None).await;
let inspection_error = inspections.iter().find_map(|inspection| match inspection {
Err(DiskError::UnsupportedDisk) | Ok(_) => None,
Err(error) => Some(error.clone()),
});
if metadata.len() != disks.len() || errors.len() != disks.len() {
return Err(DiskError::FileCorrupt);
}
@@ -519,6 +524,7 @@ pub(in crate::set_disk) async fn cleanup_source_metadata(
metadata,
errors,
certified_original: None,
inspection_error,
});
}
for (slot, original) in originals.iter_mut().enumerate() {
@@ -564,6 +570,7 @@ pub(in crate::set_disk) async fn cleanup_source_metadata(
metadata,
errors,
certified_original,
inspection_error,
})
}
+105 -17
View File
@@ -5620,6 +5620,20 @@ impl SetDisks {
metadata_sys::find_bucket_incarnation_id_in(&self.ctx, bucket).await
}
/// Confirm deletion of this exact generation using immutable retirement evidence.
/// Missing directories or unavailable bucket metadata do not prove retirement.
///
/// # Errors
/// Returns an error when the instance owner or retirement record is unavailable,
/// malformed, or bound to a different deployment or generation.
pub async fn is_bucket_generation_retired(&self, bucket: &str, incarnation: Uuid) -> Result<bool> {
let store = metadata_sys::object_store_in(&self.ctx).await?;
if !Arc::ptr_eq(&store.ctx, &self.ctx) {
return Err(Error::other("bucket retirement metadata belongs to another instance"));
}
crate::bucket::retirement::is_retired(store, bucket, incarnation).await
}
/// Admit one short scanner cache publication under this set's instance
/// movement fence. The caller must hold the returned guard through its
/// final conditional cache write; no scan-round work belongs under it.
@@ -6665,10 +6679,10 @@ impl SetDisks {
pub(crate) async fn storage_info_snapshot(&self) -> rustfs_madmin::StorageInfo {
let disks = self.get_disks_internal().await;
get_storage_info(&disks, &self.set_endpoints).await
get_storage_info(&disks, &self.set_endpoints, true).await
}
pub(crate) async fn local_storage_info_snapshot(&self) -> rustfs_madmin::StorageInfo {
pub(crate) async fn local_storage_info_snapshot(&self, include_metrics: bool) -> rustfs_madmin::StorageInfo {
let disks = self.get_disks_internal().await;
let mut local_disks: Vec<Option<DiskStore>> = Vec::new();
@@ -6681,7 +6695,7 @@ impl SetDisks {
}
}
get_storage_info(&local_disks, &local_endpoints).await
get_storage_info(&local_disks, &local_endpoints, include_metrics).await
}
pub(crate) async fn disk_inventory(&self) -> Vec<Option<DiskStore>> {
@@ -7765,11 +7779,17 @@ fn heal_metadata_identity_matches(meta: &FileInfo, latest_meta: &FileInfo) -> bo
/// drive `disk_info` timeout, and the admin peer probe budget only covers one
/// such timeout; a sequential walk over several stalled drives after a power
/// cut would exceed it and make healthy peers render as unknown (#6488).
async fn get_disks_info(disks: &[Option<DiskStore>], eps: &[Endpoint]) -> Vec<rustfs_madmin::Disk> {
join_all(disks.iter().zip(eps).map(|(disk, ep)| disk_admin_info(disk.as_ref(), ep))).await
async fn get_disks_info(disks: &[Option<DiskStore>], eps: &[Endpoint], include_metrics: bool) -> Vec<rustfs_madmin::Disk> {
join_all(
disks
.iter()
.zip(eps)
.map(|(disk, ep)| disk_admin_info(disk.as_ref(), ep, include_metrics)),
)
.await
}
async fn disk_admin_info(disk: Option<&DiskStore>, ep: &Endpoint) -> rustfs_madmin::Disk {
async fn disk_admin_info(disk: Option<&DiskStore>, ep: &Endpoint, include_metrics: bool) -> rustfs_madmin::Disk {
let Some(disk) = disk else {
return rustfs_madmin::Disk {
endpoint: ep.to_string(),
@@ -7793,14 +7813,14 @@ async fn disk_admin_info(disk: Option<&DiskStore>, ep: &Endpoint) -> rustfs_madm
let cached_disk_id = disk.cached_disk_id().await;
if !(runtime_state.should_probe_for_admin() || runtime_state == disk::health_state::RuntimeDriveHealthState::Suspect) {
let mut disk_info = build_runtime_snapshot_disk(ep, runtime_state, offline_duration_seconds, capacity_snapshot);
disk_info.metrics = disk.metrics_snapshot();
disk_info.metrics = include_metrics.then(|| disk.metrics_snapshot()).flatten();
disk_info.uuid = cached_disk_id.map_or_else(String::new, |id| id.to_string());
return disk_info;
}
match disk
.disk_info(&DiskInfoOptions {
metrics: true,
metrics: include_metrics,
..Default::default()
})
.await
@@ -7835,7 +7855,7 @@ async fn disk_admin_info(disk: Option<&DiskStore>, ep: &Endpoint) -> rustfs_madm
utilization: utilization_percent(res.total, res.used),
used_inodes: res.used_inodes,
free_inodes: res.free_inodes,
metrics: Some(res.metrics),
metrics: include_metrics.then_some(res.metrics),
..Default::default()
}
}
@@ -7850,7 +7870,7 @@ async fn disk_admin_info(disk: Option<&DiskStore>, ep: &Endpoint) -> rustfs_madm
disk_index: ep.disk_idx,
runtime_state: Some(runtime_state.as_str().to_string()),
offline_duration_seconds,
metrics: disk.metrics_snapshot(),
metrics: include_metrics.then(|| disk.metrics_snapshot()).flatten(),
uuid: cached_disk_id.map_or_else(String::new, |id| id.to_string()),
..Default::default()
};
@@ -7921,7 +7941,7 @@ fn capacity_snapshot_age_seconds(probe_unix_secs: u64) -> u64 {
.unwrap_or(probe_unix_secs);
now_unix_secs.saturating_sub(probe_unix_secs)
}
async fn get_storage_info(disks: &[Option<DiskStore>], eps: &[Endpoint]) -> rustfs_madmin::StorageInfo {
async fn get_storage_info(disks: &[Option<DiskStore>], eps: &[Endpoint], include_metrics: bool) -> rustfs_madmin::StorageInfo {
// let mut disks = get_disks_info(disks, eps).await;
// disks.sort_by(|a, b| a.total_space.cmp(&b.total_space));
//
@@ -7932,7 +7952,7 @@ async fn get_storage_info(disks: &[Option<DiskStore>], eps: &[Endpoint]) -> rust
// ..Default::default()
// },
// }
let mut disks = get_disks_info(disks, eps).await;
let mut disks = get_disks_info(disks, eps, include_metrics).await;
disks.sort_by_key(|a| a.total_space);
// Provide minimal backend shape for callers. Do NOT guess parity here since it belongs to higher-level config.
@@ -13081,7 +13101,7 @@ mod tests {
.expect("disk 2 should exist")
.force_runtime_state_for_test(RuntimeDriveHealthState::Offline);
let info = get_disks_info(&disks, &endpoints).await;
let info = get_disks_info(&disks, &endpoints, true).await;
assert_eq!(info.len(), 3);
assert_eq!(info[0].state, "ok");
@@ -13126,6 +13146,74 @@ mod tests {
);
}
#[tokio::test]
async fn local_storage_info_without_metrics_preserves_fresh_disk_observations() {
let format = FormatV3::new(1, 4);
let mut temp_dirs = Vec::new();
let mut endpoints = Vec::new();
let mut disks = Vec::new();
for disk_idx in 0..4 {
let (dir, endpoint, disk) = make_formatted_local_disk_for_info_test(disk_idx, &format).await;
temp_dirs.push(dir);
endpoints.push(endpoint);
disks.push(Some(disk));
}
let failed_disk = disks[3].as_ref().expect("failed-probe disk");
failed_disk
.set_disk_id_state(Some(Uuid::new_v4()))
.await
.expect("cache a stale disk identity");
let mut missing = endpoints[3].clone();
missing.set_disk_index(4);
endpoints.push(missing);
disks.push(None);
let mut observations = Vec::new();
for include_metrics in [true, false] {
for (index, state) in [
RuntimeDriveHealthState::Online,
RuntimeDriveHealthState::Returning,
RuntimeDriveHealthState::Offline,
RuntimeDriveHealthState::Suspect,
]
.into_iter()
.enumerate()
{
let disk = disks[index].as_ref().expect("configured test disk");
disk.force_runtime_state_for_test(state);
if state == RuntimeDriveHealthState::Offline {
disk.record_capacity_probe(100, 40, 60);
}
}
let info = get_disks_info(&disks, &endpoints, include_metrics).await;
assert_eq!(info.len(), 5);
assert!(info[..4].iter().all(|disk| disk.metrics.is_some() == include_metrics));
assert!(info[4].metrics.is_none(), "a missing slot has no metric owner");
assert_eq!(info[0].state, "ok", "online disk must retain its live probe");
assert!(info[0].total_space > 0, "online disk must retain capacity information");
assert_eq!(info[0].capacity_observation_source.as_deref(), Some("live_probe"));
assert_eq!(info[1].state, "ok", "returning disk must retain its live probe");
assert_eq!(info[1].runtime_state.as_deref(), Some("returning"));
assert_eq!(info[2].state, "offline");
assert_eq!(info[2].capacity_observation_source.as_deref(), Some("snapshot"));
assert_eq!((info[2].total_space, info[2].used_space, info[2].available_space), (100, 40, 60));
assert_ne!(info[3].state, "ok", "a stale disk identity must still fail its fresh probe");
assert_eq!(info[3].runtime_state.as_deref(), Some("suspect"));
observations.push(info);
}
for (with_metrics, without_metrics) in observations[0].iter().zip(&observations[1]) {
assert_eq!(with_metrics.endpoint, without_metrics.endpoint);
assert_eq!(with_metrics.drive_path, without_metrics.drive_path);
assert_eq!(with_metrics.uuid, without_metrics.uuid);
assert_eq!(with_metrics.state, without_metrics.state);
assert_eq!(with_metrics.runtime_state, without_metrics.runtime_state);
assert_eq!(with_metrics.pool_index, without_metrics.pool_index);
assert_eq!(with_metrics.set_index, without_metrics.set_index);
assert_eq!(with_metrics.disk_index, without_metrics.disk_index);
assert_eq!(with_metrics.total_space, without_metrics.total_space);
}
}
#[tokio::test]
async fn test_get_disks_info_probes_drives_concurrently() {
use crate::disk::disk_store::DISK_INFO_PROBE_DELAY_FOR_TEST;
@@ -13146,7 +13234,7 @@ mod tests {
let probe_delay = std::time::Duration::from_secs(2);
let started = tokio::time::Instant::now();
let info = DISK_INFO_PROBE_DELAY_FOR_TEST
.scope(probe_delay, get_disks_info(&disks, &endpoints))
.scope(probe_delay, get_disks_info(&disks, &endpoints, true))
.await;
let elapsed = started.elapsed();
@@ -13172,7 +13260,7 @@ mod tests {
.expect("remote disk id should be cached");
disk.force_runtime_state_for_test(RuntimeDriveHealthState::Offline);
let info = get_disks_info(&[Some(disk)], &[endpoint]).await;
let info = get_disks_info(&[Some(disk)], &[endpoint], true).await;
assert_eq!(info.len(), 1);
assert_eq!(info[0].state, "offline");
@@ -13190,7 +13278,7 @@ mod tests {
.expect("disk id should be cached before the failed probe");
disk.force_runtime_state_for_test(RuntimeDriveHealthState::Suspect);
let info = get_disks_info(&[Some(disk)], &[endpoint]).await;
let info = get_disks_info(&[Some(disk)], &[endpoint], true).await;
assert_eq!(info.len(), 1);
assert_eq!(info[0].runtime_state.as_deref(), Some("suspect"));
@@ -13209,7 +13297,7 @@ mod tests {
disk.record_capacity_probe(100, 40, 60);
disk.force_runtime_state_for_test(RuntimeDriveHealthState::Offline);
let info = get_disks_info(&[Some(disk)], &[endpoint]).await;
let info = get_disks_info(&[Some(disk)], &[endpoint], true).await;
assert_eq!(info.len(), 1);
assert_eq!(info[0].state, "offline");
assert_eq!(info[0].runtime_state.as_deref(), Some("offline"));
@@ -515,7 +515,7 @@ impl SetDisks {
let owner = context
.namespace_owner
.take()
.unwrap_or_else(|| self.ctx.begin_namespace_commit());
.unwrap_or_else(|| self.ctx.begin_namespace_commit_for_bucket(bucket));
context.namespace_owner = Some(Arc::new((owner, Arc::clone(&transaction_guard))));
let can_commit = context.can_commit;
let can_try_local_fast_path = disks.len() == self.set_drive_count
@@ -791,7 +791,7 @@ impl SetDisks {
let namespace_owner = context
.namespace_owner
.clone()
.unwrap_or_else(|| self.ctx.begin_namespace_commit());
.unwrap_or_else(|| self.ctx.begin_namespace_commit_for_bucket(bucket));
context.namespace_owner = Some(Arc::new((namespace_owner, guard.clone())));
}
let can_commit = context.can_commit;
@@ -821,7 +821,7 @@ impl SetDisks {
let owner = context
.namespace_owner
.take()
.unwrap_or_else(|| self.ctx.begin_namespace_commit());
.unwrap_or_else(|| self.ctx.begin_namespace_commit_for_bucket(bucket));
context.namespace_owner = Some(Arc::new((owner, Arc::clone(&transaction_guard))));
}
let DeleteRecoveryContext {
@@ -1025,7 +1025,7 @@ impl SetDisks {
let namespace_owner = if dry_run {
None
} else {
Some(namespace_owner.unwrap_or_else(|| self.ctx.begin_namespace_commit()))
Some(namespace_owner.unwrap_or_else(|| self.ctx.begin_namespace_commit_for_bucket(bucket)))
};
if !dry_run && metadata_may_change {
self.invalidate_get_object_metadata_cache(bucket, object).await;
+2 -2
View File
@@ -2060,7 +2060,7 @@ impl SetDisks {
_write_lock_guard.clone(),
_read_repair_write_lock_guard.clone(),
bucket_heal_scope.clone(),
self.ctx.begin_namespace_commit(),
self.ctx.begin_namespace_commit_for_bucket(bucket),
))
});
match disk
@@ -3761,7 +3761,7 @@ impl SetDisks {
namespace_owner: (!opts.dry_run).then(|| {
Arc::new((
scope.clone(),
self.ctx.begin_namespace_commit(),
self.ctx.begin_namespace_commit_for_bucket(bucket),
_write_lock_guard.clone(),
transaction_guard.clone(),
)) as Arc<dyn Send + Sync>
@@ -610,6 +610,9 @@ impl SetDisks {
new_disk.enable_health_check();
if new_disk.is_local() {
if let crate::disk::Disk::Local(wrapper) = new_disk.as_ref() {
wrapper.get_disk().usage_watch_binding.bind(&self.ctx.usage_watches);
}
let local_disk_map = runtime_sources::local_disk_map_handle();
let mut global_local_disk_map = local_disk_map.write().await;
let path = new_disk.endpoint().to_string();

Some files were not shown because too many files have changed in this diff Show More