From bb428bc3c6fcc5973cbf4ae6c5d254506572496a Mon Sep 17 00:00:00 2001 From: GatewayJ <835269233@qq.com> Date: Fri, 20 Nov 2026 19:13:27 +0800 Subject: [PATCH 1/5] feat(phase-3): support native RustFS NIXL/UCX object transfers --- .gitignore | 2 + Cargo.toml | 2 +- README.md | 3 +- crates/cli/src/commands/mod.rs | 2 +- crates/s3/src/client.rs | 272 +- crates/s3/src/client/staged_upload.rs | 305 ++ crates/s3/src/data_transport.rs | 44 + docs/rdma-build.md | 52 +- nixl/Cargo.lock | 4224 +++++++++++++++++++++++++ nixl/Cargo.toml | 25 + nixl/src/main.rs | 16 + nixl/src/pool.rs | 94 + nixl/src/transport.rs | 122 + nixl/src/transport/download.rs | 219 ++ nixl/src/transport/upload.rs | 162 + nixl/src/wire.rs | 116 + nixl/src/wire/native_test.rs | 47 + nixl/tests/interop.sh | 48 + 18 files changed, 5641 insertions(+), 114 deletions(-) create mode 100644 crates/s3/src/client/staged_upload.rs create mode 100644 nixl/Cargo.lock create mode 100644 nixl/Cargo.toml create mode 100644 nixl/src/main.rs create mode 100644 nixl/src/pool.rs create mode 100644 nixl/src/transport.rs create mode 100644 nixl/src/transport/download.rs create mode 100644 nixl/src/transport/upload.rs create mode 100644 nixl/src/wire.rs create mode 100644 nixl/src/wire/native_test.rs create mode 100755 nixl/tests/interop.sh diff --git a/.gitignore b/.gitignore index f0844ff5..1e045b65 100644 --- a/.gitignore +++ b/.gitignore @@ -31,3 +31,5 @@ CLAUDE.md # The independent opt-in build owns its artifacts and lockfile. /rdma/target/ /rdma/Cargo.lock + +/nixl/target/ diff --git a/Cargo.toml b/Cargo.toml index 746f35c4..2dbf5fea 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -exclude = ["rdma", "vendor/rustfs-ucx"] +exclude = ["nixl", "rdma", "vendor/rustfs-ucx"] resolver = "3" members = ["crates/cli", "crates/core", "crates/s3"] diff --git a/README.md b/README.md index 72afb132..ae11879a 100644 --- a/README.md +++ b/README.md @@ -71,8 +71,7 @@ cd cli cargo build --release ``` -Optional object-data interfaces and the explicit private build are documented -in [RDMA builds](docs/rdma-build.md). The ordinary build requires no private source. +To use RustFS native NIXL/UCX for object transfers, build the [Linux RDMA client](docs/rdma-build.md#rustfs-native-nixlucx). ## Quick Start diff --git a/crates/cli/src/commands/mod.rs b/crates/cli/src/commands/mod.rs index 213959ea..982142c5 100644 --- a/crates/cli/src/commands/mod.rs +++ b/crates/cli/src/commands/mod.rs @@ -95,7 +95,7 @@ fn validate_version_selector(version_id: Option<&str>, rewind: Option<&str>) -> #[command(propagate_version = true)] pub struct Cli { /// Object data transport: http, auto, or rdma (requires an installed provider) - #[arg(long, global = true, default_value = "http")] + #[arg(long, global = true, env = "RC_DATA_TRANSPORT", default_value = "http")] pub data_transport: DataTransportMode, /// Maximum multipart parts per object for the destination backend diff --git a/crates/s3/src/client.rs b/crates/s3/src/client.rs index d4993fd9..ddd3d911 100644 --- a/crates/s3/src/client.rs +++ b/crates/s3/src/client.rs @@ -2,6 +2,8 @@ //! //! Wraps aws-sdk-s3 and implements the ObjectStore trait from rc-core. +mod staged_upload; + use async_trait::async_trait; use aws_credential_types::Credentials; use aws_sdk_s3::error::{ProvideErrorMetadata, SdkError}; @@ -2034,6 +2036,41 @@ impl S3Client { let Some(transport) = self.selected_data_transport()? else { return Ok(None); }; + if let Some(staged) = transport.staged_upload() { + if request.content_length == 0 { + return Ok(None); + } + if let UploadOperation::PutObject { condition } = request.operation { + let options = PathUploadOptions { + write: request.options, + precondition: condition.into(), + }; + let result = self + .put_staged_object( + request.path, + staged_upload::Source::Reader(source), + request.content_length, + options, + staged, + &mut |_| {}, + ) + .await?; + return Ok(result.map(|object| UploadResult { + object, + checksum_sha256: None, + })); + } + } + self.upload_with_transport(transport.as_ref(), request, source) + .await + } + + async fn upload_with_transport( + &self, + transport: &dyn ObjectDataTransport, + request: UploadRequest<'_>, + source: &mut (dyn tokio::io::AsyncRead + Unpin + Send), + ) -> Result> { let length = request.content_length; let customer_key = destination_sse_customer_key(request.options.encryption.as_ref()).cloned(); @@ -2335,13 +2372,63 @@ impl S3Client { ) -> Result { options.validate()?; self.ensure_sse_customer_transport(options.customer_key.as_ref())?; - if self.selected_data_transport()?.is_some() { - let (mut file, temporary) = Self::temporary_download_file(destination)?; - if let Some(bytes) = self - .try_external_download(path, options, &mut file, None, &mut on_progress) - .await? - { - drop(file); + if let Some(transport) = self.selected_data_transport()? { + let (file, temporary) = Self::temporary_download_file(destination)?; + let file = Arc::new(file.into_std().await); + let result = transport + .download_file( + DownloadRequest { + path, + options, + max_bytes: None, + max_receive_bytes: rc_core::S3_MAX_OBJECT_SIZE, + on_progress: &mut on_progress, + }, + file.clone(), + ) + .await; + let bytes = match result { + Ok(Some(done)) + if done.bytes_transferred == done.content_length + && done.content_length <= rc_core::S3_MAX_OBJECT_SIZE + && file.metadata()?.len() == done.content_length => + { + Some(done.content_length) + } + Ok(Some(_)) => { + return Err(Error::DataTransfer { + state: rc_core::DataTransferState::ConfirmedFailure, + message: "Native download length differs from its temporary file".into(), + source: None, + }); + } + Ok(None) => { + let file = Arc::try_unwrap(file).map_err(|_| { + Error::General("Unused download file is still in use".into()) + })?; + self.try_external_download( + path, + options, + &mut tokio::fs::File::from_std(file), + None, + &mut on_progress, + ) + .await? + } + Err(err) + if err.state == rc_core::DataTransferState::NotAccepted + && file.metadata()?.len() == 0 + && self.data_transport_mode == rc_core::DataTransportMode::Auto => + { + None + } + Err(err) => { + return Err( + self.redact_sse_customer_error(err.into(), options.customer_key.as_ref()) + ); + } + }; + if let Some(bytes) = bytes { temporary.persist(destination).map_err(|error| { Error::General(format!( "atomically replace download destination '{}': {}", @@ -4534,7 +4621,7 @@ impl S3Client { options: PathUploadOptions<'_>, on_progress: impl Fn(u64) + Send, ) -> Result { - use aws_sdk_s3::types::{CompletedMultipartUpload, CompletedPart}; + use aws_sdk_s3::types::CompletedPart; if options.write.storage_class.is_some() { return Err(Error::UnsupportedFeature( @@ -4564,40 +4651,9 @@ impl S3Client { } tracing::debug!(file_size, part_size, "Starting multipart upload"); - let mut create_request = apply_object_write_encryption_to_multipart_create_request( - self.inner - .create_multipart_upload() - .bucket(&path.bucket) - .key(&path.key), - options.write.encryption.as_ref(), - ); - if let Some(attributes) = &options.write.attributes { - create_request = - apply_object_attributes_to_multipart_create_request(create_request, attributes)?; - } - if let Some(tags) = &options.write.tags { - create_request = create_request.tagging(encode_object_tags(tags)); - } - if checksum_requested { - create_request = - create_request.checksum_algorithm(aws_sdk_s3::types::ChecksumAlgorithm::Sha256); - } - create_request = - apply_object_lock_to_multipart_create_request(create_request, options.write)?; - - let create_response = create_request.send().await.map_err(|error| { - self.map_sdk_failure(&error, || { - self.redact_sse_customer_error( - Self::map_transfer_write_error(&error, path, options.write), - destination_sse_customer_key(options.write.encryption.as_ref()), - ) - }) - })?; - - let upload_id = create_response - .upload_id() - .ok_or_else(|| Error::General("missing upload id from multipart upload".to_string()))? - .to_string(); + let upload_id = self + .start_object_upload(path, options, checksum_requested) + .await?; tracing::debug!(upload_id = %upload_id, "Multipart upload initiated"); @@ -4755,70 +4811,16 @@ impl S3Client { part_number += 1; } - let completed_upload = CompletedMultipartUpload::builder() - .set_parts(Some(completed_parts)) - .build(); - let mut complete_request = self - .inner - .complete_multipart_upload() - .bucket(&path.bucket) - .key(&path.key) - .upload_id(&upload_id) - .multipart_upload(completed_upload); - complete_request = match options.precondition { - ObjectWritePrecondition::None => complete_request, - ObjectWritePrecondition::IfAbsent => complete_request.if_none_match("*"), - ObjectWritePrecondition::IfMatch(etag) => complete_request.if_match(etag), - }; - let complete_result = complete_request.send().await; - - let complete_response = match complete_result { - Ok(response) => response, - Err(error) => { - tracing::debug!(upload_id = %upload_id, "Attempting to abort multipart upload after completion failure"); - let primary = if !matches!(options.precondition, ObjectWritePrecondition::None) - && let aws_sdk_s3::error::SdkError::ServiceError(service_error) = &error - && matches!(service_error.raw().status().as_u16(), 409 | 412) - { - Error::Conflict(format!("Object changed before upload: {path}")) - } else { - self.redact_sse_customer_error( - Self::map_object_request_error(&error, path, None), - destination_sse_customer_key(options.write.encryption.as_ref()), - ) - }; - let primary = if has_external_parts { - let state = match &error { - aws_sdk_s3::error::SdkError::ServiceError(service_error) - if matches!(service_error.raw().status().as_u16(), 409 | 412) => - { - rc_core::DataTransferState::ConfirmedFailure - } - _ => rc_core::DataTransferState::OutcomeUnknown, - }; - Error::DataTransfer { - state, - message: "Multipart completion did not return a usable success result" - .to_string(), - source: Some(Box::new(primary)), - } - } else { - primary - }; - return Err(self - .abort_multipart_upload_with_error(path, &upload_id, primary) - .await); - } - }; - - tracing::debug!("Multipart upload completed"); - - let mut info = ObjectInfo::file(&path.key, file_size as i64); - if let Some(etag) = complete_response.e_tag() { - info.etag = Some(etag.trim_matches('"').to_string()); - } - info.version_id = complete_response.version_id().map(ToString::to_string); - info.last_modified = Some(jiff::Timestamp::now()); + let info = self + .finish_object_upload( + path, + &upload_id, + options, + completed_parts, + file_size, + has_external_parts, + ) + .await?; if checksum_requested { let expected_checksum = composite_sha256_checksum(&part_digests); @@ -4992,7 +4994,7 @@ impl S3Client { file_path: &std::path::Path, write: &ObjectWriteOptions, precondition: ObjectWritePrecondition<'_>, - on_progress: impl Fn(u64) + Send, + mut on_progress: impl Fn(u64) + Send, ) -> Result { validate_attribute_tag_write_options(write)?; self.ensure_write_sse_customer_transport(write.encryption.as_ref())?; @@ -5011,11 +5013,42 @@ impl S3Client { write, precondition, }; + let mut http; + let client = if file_size > 0 + && let Some(transport) = self.selected_data_transport()? + && let Some(staged) = transport.staged_upload() + { + let file = + std::sync::Arc::new(tokio::fs::File::open(file_path).await?.into_std().await); + if file.metadata()?.len() != file_size { + return Err(Error::Conflict("Upload source length changed".into())); + } + if let Some(info) = self + .put_staged_object( + path, + staged_upload::Source::File(file), + file_size, + options, + staged, + &mut on_progress, + ) + .await? + { + return Ok(info); + } + http = self.clone(); + http.data_transport_mode = rc_core::DataTransportMode::Http; + &http + } else { + self + }; if Self::should_use_multipart(file_size) { - self.put_object_multipart_from_path(path, file_path, file_size, options, on_progress) + client + .put_object_multipart_from_path(path, file_path, file_size, options, on_progress) .await } else { - self.put_object_single_part_from_path(path, file_path, options, on_progress) + client + .put_object_single_part_from_path(path, file_path, options, on_progress) .await } } @@ -7815,6 +7848,20 @@ impl ObjectStore for S3Client { #[async_trait] impl ControlExecutor for S3Client { async fn execute(&self, request: ControlRequest) -> Result { + self.execute_control(request, true).await + } + + async fn execute_headers(&self, request: ControlRequest) -> Result { + self.execute_control(request, false).await + } +} + +impl S3Client { + async fn execute_control( + &self, + request: ControlRequest, + read_body: bool, + ) -> Result { if self.alias.anonymous { return Err(Error::RequestRejected( "External object control requires an authenticated S3 principal".to_string(), @@ -7941,6 +7988,13 @@ impl ControlExecutor for S3Client { .map_err(|_| Error::Network("External control exchange failed".to_string()))?; let status = response.status(); let headers = response.headers().clone(); + if !read_body { + return Ok(ControlResponse { + status, + headers, + body: Bytes::new(), + }); + } if response .content_length() .is_some_and(|length| length > request.response_limit as u64) diff --git a/crates/s3/src/client/staged_upload.rs b/crates/s3/src/client/staged_upload.rs new file mode 100644 index 00000000..5959b3f5 --- /dev/null +++ b/crates/s3/src/client/staged_upload.rs @@ -0,0 +1,305 @@ +//! Publish native buffer uploads only after every unpublished S3 part has a receipt. + +use super::*; +use crate::data_transport::StagedUploadTransport; +use aws_sdk_s3::types::{CompletedMultipartUpload, CompletedPart}; + +pub(super) enum Source<'a> { + File(Arc), + Reader(&'a mut (dyn tokio::io::AsyncRead + Unpin + Send)), +} + +/// Cancellation drops the caller's future before its ordinary error path runs. +struct PendingUpload<'a> { + client: &'a S3Client, + path: &'a RemotePath, + id: Option, +} + +impl Drop for PendingUpload<'_> { + fn drop(&mut self) { + if let Some(id) = self.id.take() + && let Ok(runtime) = tokio::runtime::Handle::try_current() + { + let client = self.client.clone(); + let path = self.path.clone(); + runtime.spawn(async move { + client.abort_multipart_upload_best_effort(&path, &id).await; + }); + } + } +} + +impl<'a> From> for ObjectWritePrecondition<'a> { + fn from(value: WriteCondition<'a>) -> Self { + match value { + WriteCondition::None => Self::None, + WriteCondition::IfAbsent => Self::IfAbsent, + WriteCondition::IfMatch(etag) => Self::IfMatch(etag), + } + } +} + +impl S3Client { + pub(super) async fn start_object_upload( + &self, + path: &RemotePath, + options: PathUploadOptions<'_>, + checksum_requested: bool, + ) -> Result { + let mut create_request = apply_object_write_encryption_to_multipart_create_request( + self.inner + .create_multipart_upload() + .bucket(&path.bucket) + .key(&path.key), + options.write.encryption.as_ref(), + ); + if let Some(attributes) = &options.write.attributes { + create_request = + apply_object_attributes_to_multipart_create_request(create_request, attributes)?; + } + if let Some(tags) = &options.write.tags { + create_request = create_request.tagging(encode_object_tags(tags)); + } + if checksum_requested { + create_request = + create_request.checksum_algorithm(aws_sdk_s3::types::ChecksumAlgorithm::Sha256); + } + create_request = + apply_object_lock_to_multipart_create_request(create_request, options.write)?; + + let create_response = create_request.send().await.map_err(|error| { + self.map_sdk_failure(&error, || { + self.redact_sse_customer_error( + Self::map_transfer_write_error(&error, path, options.write), + destination_sse_customer_key(options.write.encryption.as_ref()), + ) + }) + })?; + + Ok(create_response + .upload_id() + .ok_or_else(|| Error::General("missing upload id from multipart upload".to_string()))? + .to_string()) + } + + pub(super) async fn finish_object_upload( + &self, + path: &RemotePath, + upload_id: &str, + options: PathUploadOptions<'_>, + completed_parts: Vec, + file_size: u64, + has_external_parts: bool, + ) -> Result { + let completed_upload = CompletedMultipartUpload::builder() + .set_parts(Some(completed_parts)) + .build(); + let mut complete_request = self + .inner + .complete_multipart_upload() + .bucket(&path.bucket) + .key(&path.key) + .upload_id(upload_id) + .multipart_upload(completed_upload); + complete_request = match options.precondition { + ObjectWritePrecondition::None => complete_request, + ObjectWritePrecondition::IfAbsent => complete_request.if_none_match("*"), + ObjectWritePrecondition::IfMatch(etag) => complete_request.if_match(etag), + }; + let complete_result = complete_request.send().await; + + let complete_response = match complete_result { + Ok(response) => response, + Err(error) => { + tracing::debug!(upload_id = %upload_id, "Attempting to abort multipart upload after completion failure"); + let primary = if !matches!(options.precondition, ObjectWritePrecondition::None) + && let aws_sdk_s3::error::SdkError::ServiceError(service_error) = &error + && matches!(service_error.raw().status().as_u16(), 409 | 412) + { + Error::Conflict(format!("Object changed before upload: {path}")) + } else { + self.redact_sse_customer_error( + Self::map_object_request_error(&error, path, None), + destination_sse_customer_key(options.write.encryption.as_ref()), + ) + }; + let primary = if has_external_parts { + let state = match &error { + aws_sdk_s3::error::SdkError::ServiceError(service_error) + if matches!(service_error.raw().status().as_u16(), 409 | 412) => + { + rc_core::DataTransferState::ConfirmedFailure + } + _ => rc_core::DataTransferState::OutcomeUnknown, + }; + Error::DataTransfer { + state, + message: "Multipart completion did not return a usable success result" + .to_string(), + source: Some(Box::new(primary)), + } + } else { + primary + }; + return Err(self + .abort_multipart_upload_with_error(path, upload_id, primary) + .await); + } + }; + + tracing::debug!("Multipart upload completed"); + + let mut info = ObjectInfo::file(&path.key, file_size as i64); + if let Some(etag) = complete_response.e_tag() { + info.etag = Some(etag.trim_matches('"').to_string()); + } + info.version_id = complete_response.version_id().map(ToString::to_string); + info.last_modified = Some(jiff::Timestamp::now()); + + Ok(info) + } + + pub(super) async fn put_staged_object( + &self, + path: &RemotePath, + source: Source<'_>, + length: u64, + options: PathUploadOptions<'_>, + staged: &dyn StagedUploadTransport, + progress: &mut (dyn FnMut(u64) + Send), + ) -> Result> { + let auto = self.data_transport_mode == rc_core::DataTransportMode::Auto; + let endpoint = if self.alias.anonymous { + Err(Error::RequestRejected( + "Native object transfer requires a signed S3 request".into(), + )) + } else { + self.external_control_url(path, &[]).map(|_| ()) + }; + if let Err(error) = endpoint { + return if auto { Ok(None) } else { Err(error) }; + } + let part_size = crate::multipart::MultipartConfig::default() + .checked_part_size(length, rc_core::global_multipart_max_parts())?; + if options.write.checksum.is_some() + || options.write.storage_class.is_some() + || destination_sse_customer_key(options.write.encryption.as_ref()).is_some() + || part_size.min(length) > staged.max_part_size() + { + return if auto { + Ok(None) + } else { + Err(Error::UnsupportedFeature("This part size, storage class, explicit S3 checksum or SSE-C request is unavailable with native multipart transport".into())) + }; + } + let upload_id = self.start_object_upload(path, options, false).await?; + let mut pending = PendingUpload { + client: self, + path, + id: Some(upload_id.clone()), + }; + let upload = async { + if auto { + match staged.probe(path, &upload_id, part_size.min(length)).await { + Ok(true) => {} + Ok(false) => return Ok(None), + Err(error) if error.state == rc_core::DataTransferState::NotAccepted => { + return Ok(None); + } + Err(error) => return Err(error.into()), + } + } + let count = length.div_ceil(part_size); + let part_request = |i: u64| UploadRequest { + path, + options: options.write, + operation: UploadOperation::UploadPart { + upload_id: &upload_id, + part_number: i as i32 + 1, + }, + content_length: part_size.min(length - i * part_size), + checksum_sha256: None, + }; + let mut parts = Vec::with_capacity(count as usize); + let mut transferred = 0; + let mut finish_part = |i: u64, result: UploadResult| -> Result<()> { + let etag = result + .object + .etag + .ok_or_else(|| Error::General("Native part has no ETag".into()))?; + parts.push( + CompletedPart::builder() + .part_number(i as i32 + 1) + .e_tag(etag) + .build(), + ); + transferred += part_request(i).content_length; + progress(transferred); + Ok(()) + }; + match source { + Source::File(file) => { + // Ordered collection preserves the completion manifest while two + // independent positional reads and transfers can run concurrently. + let send = |i: u64| { + staged.upload_file_part(part_request(i), Arc::clone(&file), i * part_size) + }; + for i in (0..count).step_by(2) { + if i + 1 == count { + finish_part(i, send(i).await?)?; + } else { + let (first, second) = tokio::join!(send(i), send(i + 1)); + finish_part(i, first?)?; + finish_part(i + 1, second?)?; + } + } + if file.metadata()?.len() != length { + return Err(Error::Conflict("Upload source length changed".into())); + } + } + Source::Reader(source) => { + for i in 0..count { + let request = part_request(i); + let mut part = (&mut *source).take(request.content_length); + let result = self + .upload_with_transport(staged, request, &mut part) + .await? + .ok_or_else(|| { + Error::UnsupportedFeature("Native part transfer declined".into()) + })?; + finish_part(i, result)?; + } + if source.read(&mut [0_u8; 1]).await? != 0 { + return Err(Error::Conflict( + "Upload source exceeds its declared length".into(), + )); + } + } + } + Ok(Some(parts)) + } + .await; + let result = match upload { + Ok(Some(parts)) => self + .finish_object_upload(path, &upload_id, options, parts, length, true) + .await + .map(Some), + Ok(None) => match self + .abort_multipart_upload_best_effort(path, &upload_id) + .await + { + MultipartAbortStatus::Succeeded => Ok(None), + status => Err( + Error::General("Could not abort the native upload probe".into()) + .with_multipart_copy_context(&upload_id, status), + ), + }, + Err(error) => Err(self + .abort_multipart_upload_with_error(path, &upload_id, error) + .await), + }; + pending.id = None; + result + } +} diff --git a/crates/s3/src/data_transport.rs b/crates/s3/src/data_transport.rs index 41cbe2be..9810493e 100644 --- a/crates/s3/src/data_transport.rs +++ b/crates/s3/src/data_transport.rs @@ -54,6 +54,12 @@ pub struct ControlResponse { #[async_trait] pub trait ControlExecutor: Send + Sync { async fn execute(&self, request: ControlRequest) -> Result; + + /// Return only the status and headers. A server may decline an external GET + /// by streaming an ordinary S3 payload of arbitrary size. + async fn execute_headers(&self, request: ControlRequest) -> Result { + self.execute(request).await + } } /// Configuration passed to a process-installed provider factory. @@ -167,6 +173,28 @@ pub(crate) fn committed_verification_failure(source: Error) -> Error { } } +/// Access to unpublished S3 parts for providers without atomic direct PUT negotiation. +#[async_trait] +pub trait StagedUploadTransport: ObjectDataTransport { + fn max_part_size(&self) -> u64; + + /// Probe part 1 of a newly created upload before reading application data. + async fn probe( + &self, + path: &RemotePath, + upload_id: &str, + first_part_bytes: u64, + ) -> DataTransportResult; + + /// Read an exact file range directly into registered memory. + async fn upload_file_part( + &self, + request: UploadRequest<'_>, + file: Arc, + offset: u64, + ) -> DataTransportResult; +} + /// One provider call performs one S3 data operation and its owned reconciliation. /// /// Success requires authenticated acceptance, exact logical length, data @@ -175,6 +203,22 @@ pub(crate) fn committed_verification_failure(source: Error) -> Error { /// retain their classification; callers never infer replay safety from strings. #[async_trait] pub trait ObjectDataTransport: Send + Sync { + /// A server which can interpret a declined external PUT as an empty S3 PUT + /// must receive data only into unpublished multipart parts. + fn staged_upload(&self) -> Option<&dyn StagedUploadTransport> { + None + } + + /// Write verified data directly to the host's unpublished temporary file. + /// Providers using the streaming sink return None without accessing the file. + async fn download_file( + &self, + _request: DownloadRequest<'_>, + _file: Arc, + ) -> DataTransportResult> { + Ok(None) + } + async fn download( &self, request: DownloadRequest<'_>, diff --git a/docs/rdma-build.md b/docs/rdma-build.md index 2e131f45..9b9cb4a0 100644 --- a/docs/rdma-build.md +++ b/docs/rdma-build.md @@ -1,4 +1,54 @@ -# Optional external object data build +# Object data over RDMA + +## RustFS native NIXL/UCX + +Build on Linux with Rust 1.99 or later, libclang, a C++ compiler and the +NIXL libraries, headers and UCX plugin used by the RustFS server. Set +`NIXL_PREFIX` to the native installation before building. At runtime set +`LD_LIBRARY_PATH` to include its library directory and `NIXL_PLUGIN_DIR` to +its plugin directory. Set `UCX_NET_DEVICES` to select client network devices +when needed. The native package pins the same `rustfs-nixl` and +`nixl-sys` sources as the server. + +```sh +cargo build --manifest-path nixl/Cargo.toml --release --locked +export PATH="$PWD/nixl/target/release:$PATH" +rc --data-transport rdma cp model.bin local/models/model.bin +rc --data-transport rdma cp local/models/model.bin downloaded.bin +``` + +Configure a verified HTTPS alias and start RustFS with its `nixl` Cargo +feature and `RUSTFS_NIXL_ENABLE=true`. For a private CA, pass +`--ca-bundle /path/to/ca.pem` to `rc alias set`. Set `RC_DATA_TRANSPORT=auto` +or `rdma` to reuse the selection across commands. The default is `http`. + +File uploads use positional reads directly into two reusable registered +windows. For transfers of up to 1 MiB, the client can register two 1 MiB +windows. Larger transfers use 64 MiB windows, which also serve subsequent +small requests on the same client. File downloads write directly into the temporary +destination file. A range GET for the next window can proceed while the +previous window is being written. The client selects a version and uses +`If-Match` to keep ranges consistent. Downloads publish the temporary file +after verifying the transfer count and any applicable object checksum. + +RustFS can interpret a declined external PUT as an ordinary empty PUT. +The client uploads nonempty objects into unpublished multipart parts and +completes the upload only after RustFS confirms every part. This requires +multipart permissions and produces multipart ETags even for a single part. +In `auto` mode a one-byte probe of the new upload precedes reading the +source. A normal HTTP response to that probe aborts the temporary upload +and selects the ordinary S3 path. Empty uploads use ordinary S3. Uploads +with an explicit S3 checksum, SSE-C, a storage class or a required part +size above 64 MiB use HTTP in `auto` and report an error in `rdma`. + +To run the real two-agent memory transfer test, use +`cargo test --manifest-path nixl/Cargo.toml --locked`. For an S3 command +round trip, set `RC` to the native executable and supply disposable buckets +in `NIXL_BUCKET` and `HTTP_BUCKET` on enabled and disabled endpoints. Run +`nixl/tests/interop.sh` with those variables. `UCX_TLS=tcp,self` exercises +the protocol on a machine without an RDMA network adapter. + +## Private gateway protocol The normal workspace builds without access to the private transport repository: diff --git a/nixl/Cargo.lock b/nixl/Cargo.lock new file mode 100644 index 00000000..7e41930a --- /dev/null +++ b/nixl/Cargo.lock @@ -0,0 +1,4224 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 4 + +[[package]] +name = "aead" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0" +dependencies = [ + "crypto-common 0.1.7", + "generic-array", +] + +[[package]] +name = "aes" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0" +dependencies = [ + "cfg-if", + "cipher", + "cpufeatures 0.2.17", +] + +[[package]] +name = "aes-gcm" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1" +dependencies = [ + "aead", + "aes", + "cipher", + "ctr", + "ghash", + "subtle", +] + +[[package]] +name = "aho-corasick" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c982642fa9e8606056828ee9a8505737230110bb1099153c79efe865c59d12ba" +dependencies = [ + "memchr", +] + +[[package]] +name = "android_system_properties" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae221649c9976a6f6c56ae1facf410f3ddb33cc661c4b7b61020a912d4237fbc" +dependencies = [ + "libc", +] + +[[package]] +name = "anstream" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d" +dependencies = [ + "anstyle", + "anstyle-parse", + "anstyle-query", + "anstyle-wincon", + "colorchoice", + "is_terminal_polyfill", + "utf8parse", +] + +[[package]] +name = "anstyle" +version = "1.0.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000" + +[[package]] +name = "anstyle-parse" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e" +dependencies = [ + "utf8parse", +] + +[[package]] +name = "anstyle-query" +version = "1.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "anstyle-wincon" +version = "3.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d" +dependencies = [ + "anstyle", + "once_cell_polyfill", + "windows-sys 0.61.2", +] + +[[package]] +name = "anyhow" +version = "1.0.104" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470" + +[[package]] +name = "arc-swap" +version = "1.9.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db4c94f57a570fce5d381be3289b3f79aef6332d72948fe82ab5772e423ccf92" +dependencies = [ + "rustversion", +] + +[[package]] +name = "asn1-rs" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7f43a50ac4fdca5df8e885c21b835997f0a1cdee65494a6847694a98652d9d8" +dependencies = [ + "asn1-rs-derive", + "asn1-rs-impl", + "displaydoc", + "nom", + "num-traits", + "rusticata-macros", + "thiserror", + "time", +] + +[[package]] +name = "asn1-rs-derive" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3109e49b1e4909e9db6515a30c633684d68cdeaa252f215214cb4fa1a5bfee2c" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", + "synstructure 0.13.2", +] + +[[package]] +name = "asn1-rs-impl" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b18050c2cd6fe86c3a76584ef5e0baf286d038cda203eb6223df2cc413565f7" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "async-trait" +version = "0.1.92" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82f6aeea286b8eb4dd3431a1be1b59d290ace00f5bfd8e2a159bc2a05e2c1667" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "atomic-waker" +version = "1.1.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0" + +[[package]] +name = "autocfg" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53" + +[[package]] +name = "aws-config" +version = "1.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "939e256cfe0ed68e96d32f194339d88210d5c10685cff0787400158f852c6819" +dependencies = [ + "aws-credential-types", + "aws-runtime", + "aws-sdk-sso", + "aws-sdk-ssooidc", + "aws-sdk-sts", + "aws-smithy-async", + "aws-smithy-http", + "aws-smithy-json", + "aws-smithy-runtime", + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "aws-types", + "bytes", + "fastrand", + "hex", + "http", + "sha1 0.10.7", + "time", + "tokio", + "tracing", + "url", + "zeroize", +] + +[[package]] +name = "aws-credential-types" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "576e8da35751dc85409ec1cd15999f692c277a1fbe9336780fe6f15e49dd637d" +dependencies = [ + "aws-smithy-async", + "aws-smithy-runtime-api", + "aws-smithy-types", + "zeroize", +] + +[[package]] +name = "aws-lc-rs" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "048006790404103c488e6c5616b3e7e702a71292aadda08e8f7698a9e0d2eb53" +dependencies = [ + "aws-lc-sys", + "zeroize", +] + +[[package]] +name = "aws-lc-sys" +version = "0.47.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8bfbe32ac36b3c428696ce315464181bc4029d689fd58e3f2a4e58c252242f52" +dependencies = [ + "cc", + "cmake", + "dunce", + "fs_extra", + "pkg-config", +] + +[[package]] +name = "aws-runtime" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a0cc2144962cc5e358467b16e3d82981b1d424a7c3d34602be0036103814a1a" +dependencies = [ + "aws-credential-types", + "aws-sigv4", + "aws-smithy-async", + "aws-smithy-eventstream", + "aws-smithy-http", + "aws-smithy-runtime", + "aws-smithy-runtime-api", + "aws-smithy-types", + "aws-types", + "bytes", + "bytes-utils", + "fastrand", + "http", + "http-body", + "percent-encoding", + "pin-project-lite", + "tracing", + "uuid", +] + +[[package]] +name = "aws-sdk-s3" +version = "1.157.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ea9794c741520d8baec9462bcd0ad12164d4f5f78d008a8da9d6a0b7222caa8" +dependencies = [ + "arc-swap", + "aws-credential-types", + "aws-runtime", + "aws-sigv4", + "aws-smithy-async", + "aws-smithy-checksums", + "aws-smithy-eventstream", + "aws-smithy-http", + "aws-smithy-json", + "aws-smithy-observability", + "aws-smithy-runtime", + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "aws-smithy-xml", + "aws-types", + "bytes", + "fastrand", + "hex", + "hmac", + "http", + "http-body", + "lru", + "percent-encoding", + "regex-lite", + "sha2 0.11.1", + "tracing", + "url", +] + +[[package]] +name = "aws-sdk-sso" +version = "1.119.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c414f25ec4aa9dc18f5cc8f55e18848bb509fcda4ce7c77bee6072e95806bc9" +dependencies = [ + "arc-swap", + "aws-credential-types", + "aws-runtime", + "aws-smithy-async", + "aws-smithy-http", + "aws-smithy-json", + "aws-smithy-observability", + "aws-smithy-runtime", + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "aws-types", + "bytes", + "fastrand", + "http", + "regex-lite", + "tracing", +] + +[[package]] +name = "aws-sdk-ssooidc" +version = "1.121.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bc638bb4355e6514334dcc3228cd4622f5ee54d704bd6a9010a5a91d7856d9d9" +dependencies = [ + "arc-swap", + "aws-credential-types", + "aws-runtime", + "aws-smithy-async", + "aws-smithy-http", + "aws-smithy-json", + "aws-smithy-observability", + "aws-smithy-runtime", + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "aws-types", + "bytes", + "fastrand", + "http", + "regex-lite", + "tracing", +] + +[[package]] +name = "aws-sdk-sts" +version = "1.124.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f8a0dd8fbde04ba58ad722113c7addb11bf94cf549b1ea0eb9ea427fb87198a" +dependencies = [ + "arc-swap", + "aws-credential-types", + "aws-runtime", + "aws-smithy-async", + "aws-smithy-http", + "aws-smithy-json", + "aws-smithy-observability", + "aws-smithy-query", + "aws-smithy-runtime", + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "aws-smithy-xml", + "aws-types", + "fastrand", + "http", + "regex-lite", + "tracing", +] + +[[package]] +name = "aws-sigv4" +version = "1.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f385da9b7757ed4c8214797ad663ff534fb622006143530aa80e21f8e06ff85c" +dependencies = [ + "aws-credential-types", + "aws-smithy-eventstream", + "aws-smithy-http", + "aws-smithy-runtime-api", + "aws-smithy-types", + "bytes", + "form_urlencoded", + "hex", + "hmac", + "http", + "percent-encoding", + "sha2 0.11.1", + "time", + "tracing", +] + +[[package]] +name = "aws-smithy-async" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "de681a9df7ff79823b759ee17061076ec049cd61a8fa28ece4293d89c9f6964e" +dependencies = [ + "futures-util", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "aws-smithy-checksums" +version = "0.65.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ab2f2d12a431aab3703d55277278bad45f02208569b11506220b95fdc1ef0507" +dependencies = [ + "aws-smithy-http", + "aws-smithy-types", + "bytes", + "crc-fast", + "hex", + "http", + "http-body", + "http-body-util", + "md-5 0.11.0", + "pin-project-lite", + "sha1 0.11.0", + "sha2 0.11.1", + "tracing", +] + +[[package]] +name = "aws-smithy-eventstream" +version = "0.61.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "14c8a643d0e114cae39e45415e3225793a6396698b7779a0c9e3ede731d8fc71" +dependencies = [ + "aws-smithy-types", + "bytes", + "crc32fast", +] + +[[package]] +name = "aws-smithy-http" +version = "0.64.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "19af609dd5edf8b056cd0bb001c706c8b3b1458055328b334ec13d7f46f6aaa8" +dependencies = [ + "aws-smithy-eventstream", + "aws-smithy-runtime-api", + "aws-smithy-types", + "bytes", + "bytes-utils", + "futures-core", + "futures-util", + "http", + "http-body", + "http-body-util", + "percent-encoding", + "pin-project-lite", + "tracing", +] + +[[package]] +name = "aws-smithy-http-client" +version = "1.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "859a81364f8185349c584fb41cd8765a400cf982f447adada590cf008a9f3b85" +dependencies = [ + "aws-smithy-async", + "aws-smithy-runtime-api", + "aws-smithy-types", + "h2", + "http", + "hyper", + "hyper-rustls", + "hyper-util", + "pin-project-lite", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "tokio", + "tokio-rustls", + "tower", + "tracing", +] + +[[package]] +name = "aws-smithy-json" +version = "0.65.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b45f9fc77ffe92c92c341165a01a565bd30c39ecf5aa8c0719b41719009604f9" +dependencies = [ + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", +] + +[[package]] +name = "aws-smithy-observability" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a416257d7b1b0f32a517a470a8c1dd354d8c4aa697ccab81a11a1e6cfb7418e3" +dependencies = [ + "aws-smithy-runtime-api", + "aws-smithy-types", + "tracing", +] + +[[package]] +name = "aws-smithy-query" +version = "0.64.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "165f6265342a313ad6f7a1ac17a0cdba30c522039d3f41d8d6871ce8a2b34ecd" +dependencies = [ + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "aws-smithy-xml", + "urlencoding", +] + +[[package]] +name = "aws-smithy-runtime" +version = "1.16.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cb80fb19c084da5fca9d797845735e184445e5b958599440d67529bf6ef1b64" +dependencies = [ + "aws-smithy-async", + "aws-smithy-http", + "aws-smithy-http-client", + "aws-smithy-observability", + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "bytes", + "fastrand", + "http", + "http-body", + "http-body-util", + "pin-project-lite", + "tokio", + "tracing", +] + +[[package]] +name = "aws-smithy-runtime-api" +version = "1.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d06a8615310f03c73ea8eea607ee1a9cb17b7ebe055b9152feda1d86831c215c" +dependencies = [ + "aws-smithy-async", + "aws-smithy-runtime-api-macros", + "aws-smithy-types", + "bytes", + "http", + "pin-project-lite", + "tokio", + "tracing", + "zeroize", +] + +[[package]] +name = "aws-smithy-runtime-api-macros" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce237f890a2283c9b328955c3b0918d2d5bf66a1cb6ceccd36a0047246fbc6e6" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "aws-smithy-schema" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7ef30d39e131651359b60a1c560de9a9502a4c3754172ab2d6e8734fe21bcba" +dependencies = [ + "aws-smithy-runtime-api", + "aws-smithy-types", + "http", +] + +[[package]] +name = "aws-smithy-types" +version = "1.9.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6c3a040d8b963838a01d7d239b0118357388d0ab881857bb5fc2dd780bb87957" +dependencies = [ + "base64-simd", + "bytes", + "bytes-utils", + "futures-core", + "http", + "http-body", + "http-body-util", + "itoa", + "pin-project-lite", + "ryu", + "serde", + "time", + "tokio", + "tokio-util", +] + +[[package]] +name = "aws-smithy-xml" +version = "0.64.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "590fdc1a70546b2f7f2061c42eaf173fb6f26d935330d069edc04dbd8f01d924" +dependencies = [ + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "xmlparser", +] + +[[package]] +name = "aws-types" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ba0d970d3947bb064d2ae1d823efa186c1dbde88f88afa8f6549946e5d8deee" +dependencies = [ + "aws-credential-types", + "aws-smithy-async", + "aws-smithy-runtime-api", + "aws-smithy-schema", + "aws-smithy-types", + "rustc_version", + "tracing", +] + +[[package]] +name = "base64" +version = "0.22.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6" + +[[package]] +name = "base64" +version = "0.23.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5" + +[[package]] +name = "base64-simd" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "339abbe78e73178762e23bea9dfd08e697eb3f3301cd4be981c0f78ba5859195" +dependencies = [ + "outref", + "vsimd", +] + +[[package]] +name = "base64ct" +version = "1.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2af50177e190e07a26ab74f8b1efbfe2ef87da2116221318cb1c2e82baf7de06" + +[[package]] +name = "bindgen" +version = "0.71.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" +dependencies = [ + "bitflags", + "cexpr", + "clang-sys", + "itertools", + "log", + "prettyplease", + "proc-macro2", + "quote", + "regex", + "rustc-hash", + "shlex 1.3.0", + "syn 2.0.119", +] + +[[package]] +name = "bitflags" +version = "2.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ded4057c258ba199e2d26386d3af3780957ecaee6c4ef4041c6b4b8b97c0b06" + +[[package]] +name = "block-buffer" +version = "0.10.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" +dependencies = [ + "generic-array", +] + +[[package]] +name = "block-buffer" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa" +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 = "bumpalo" +version = "3.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649" + +[[package]] +name = "bytes" +version = "1.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "776dfebd015e2d8732c684a2c71003674ccb49457b539b9e82151ba38e96dd7c" + +[[package]] +name = "bytes-utils" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7dafe3a8757b027e2be6e4e5601ed563c55989fcf1546e933c66c8eb3a058d35" +dependencies = [ + "bytes", + "either", +] + +[[package]] +name = "cc" +version = "1.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ff2a8126fff0f8c839080d619675a585e61720bb12d2baceae45769fd66f155" +dependencies = [ + "find-msvc-tools", + "jobserver", + "libc", + "shlex 2.0.1", +] + +[[package]] +name = "cexpr" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766" +dependencies = [ + "nom", +] + +[[package]] +name = "cfg-if" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600" + +[[package]] +name = "cfg_aliases" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f079e83a288787bcd14a6aea84cee5c87a67c5a3e660c30f557a3d24761b3527" + +[[package]] +name = "chacha20" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.1", + "rand_core 0.10.1", +] + +[[package]] +name = "cipher" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" +dependencies = [ + "crypto-common 0.1.7", + "inout", +] + +[[package]] +name = "clang-sys" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "157a8ba7b480713b56f4c09fd13fc3e0a22a5dfab8097ba61cbc5feef950788a" +dependencies = [ + "glob", + "libc", + "libloading", +] + +[[package]] +name = "clap" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aa8876b300ab35ba921adea3dfd70157a46249b33f95c9084ae5709785478946" +dependencies = [ + "clap_builder", + "clap_derive", +] + +[[package]] +name = "clap_builder" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0797fb7aeb1406c84efac526901f7ec3ead2124f946b494e72879d4b54704d" +dependencies = [ + "anstream", + "anstyle", + "clap_lex", + "strsim", +] + +[[package]] +name = "clap_complete" +version = "4.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "037e2a1a92236d0aff7e845093f64661d6df4c02c9fcc61a60e9e1d736fa392f" +dependencies = [ + "clap", +] + +[[package]] +name = "clap_derive" +version = "4.6.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9c751b79415d4e559e3d1fcf128e09e720eb673a06d26cf6f392d37d75b66e0" +dependencies = [ + "heck", + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "clap_lex" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c133bc6a41be0d194c306b5506d15e6feeea7b1d6604bd3f8310dfb2ca96486" + +[[package]] +name = "cmake" +version = "0.1.58" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c0f78a02292a74a88ac736019ab962ece0bc380e3f977bf72e376c5d78ff0678" +dependencies = [ + "cc", +] + +[[package]] +name = "cmov" +version = "0.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c9ea0ac24bc397ab3c98583a3c9ba74fa56b09a4449bbe172b9b1ddb016027a" + +[[package]] +name = "colorchoice" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570" + +[[package]] +name = "comfy-table" +version = "7.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "958c5d6ecf1f214b4c2bbbbf6ab9523a864bd136dcf71a7e8904799acfe1ad47" +dependencies = [ + "crossterm", + "unicode-segmentation", + "unicode-width", +] + +[[package]] +name = "console" +version = "0.16.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e96a4956774c13c126a8b5af4daa79384f4d826534c95a02d76afb39e2ab64e3" +dependencies = [ + "encode_unicode", + "libc", + "unicode-width", + "windows-sys 0.61.2", +] + +[[package]] +name = "const-oid" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" + +[[package]] +name = "const-oid" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c" + +[[package]] +name = "constant_time_eq" +version = "0.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9eb6feb175df65d0a3ccd3e73484e940d0ac664e8034f0519fd49a93db3071d9" +dependencies = [ + "rustversion", +] + +[[package]] +name = "core-foundation" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "core-foundation-sys" +version = "0.8.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b" + +[[package]] +name = "cpufeatures" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280" +dependencies = [ + "libc", +] + +[[package]] +name = "cpufeatures" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566" +dependencies = [ + "libc", +] + +[[package]] +name = "crc-fast" +version = "1.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e75b2483e97a5a7da73ac68a05b629f9c53cff58d8ed1c77866079e18b00dba5" +dependencies = [ + "digest 0.10.7", + "spin 0.10.1", +] + +[[package]] +name = "crc32fast" +version = "1.5.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f97d3416d5337d15c4b0d78c8c91df922ca143f57ec20e2d1c188333047ef04" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "crossterm" +version = "0.29.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d8b9f2e4c67f833b660cdb0a3523065869fb35570177239812ed4c905aeff87b" +dependencies = [ + "bitflags", + "crossterm_winapi", + "document-features", + "parking_lot 0.12.5", + "rustix", + "winapi", +] + +[[package]] +name = "crossterm_winapi" +version = "0.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b" +dependencies = [ + "winapi", +] + +[[package]] +name = "crypto-common" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" +dependencies = [ + "generic-array", + "rand_core 0.6.4", + "typenum", +] + +[[package]] +name = "crypto-common" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453" +dependencies = [ + "hybrid-array", +] + +[[package]] +name = "ctr" +version = "0.9.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" +dependencies = [ + "cipher", +] + +[[package]] +name = "ctutils" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "261af4dc7a06ea8a527a8717d8cbba3417530d6ea14e1edb3de6b67806be474f" +dependencies = [ + "cmov", +] + +[[package]] +name = "darling" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25ae13da2f202d56bd7f91c25fba009e7717a1e4a1cc98a76d844b65ae912e9d" +dependencies = [ + "darling_core", + "darling_macro", +] + +[[package]] +name = "darling_core" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9865a50f7c335f53564bb694ef660825eb8610e0a53d3e11bf1b0d3df31e03b0" +dependencies = [ + "ident_case", + "proc-macro2", + "quote", + "strsim", + "syn 2.0.119", +] + +[[package]] +name = "darling_macro" +version = "0.23.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3984ec7bd6cfa798e62b4a642426a5be0e68f9401cfc2a01e3fa9ea2fcdb8d" +dependencies = [ + "darling_core", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "data-encoding" +version = "2.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4583a4551df46e2792f82ceeac45e850d2e2d5debba0b91f102385cda5b11f06" + +[[package]] +name = "der" +version = "0.7.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7c1832837b905bbfb5101e07cc24c8deddf52f93225eee6ead5f4d63d53ddcb" +dependencies = [ + "const-oid 0.9.6", + "pem-rfc7468", + "zeroize", +] + +[[package]] +name = "der-parser" +version = "10.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "07da5016415d5a3c4dd39b11ed26f915f52fc4e0dc197d87908bc916e51bc1a6" +dependencies = [ + "asn1-rs", + "displaydoc", + "nom", + "num-bigint", + "num-traits", + "rusticata-macros", +] + +[[package]] +name = "deranged" +version = "0.5.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e9de72ce2ad1f90dc62fa25f0f430ef85eb4b0d8fa0be4f30373bc40a21d28e" + +[[package]] +name = "digest" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" +dependencies = [ + "block-buffer 0.10.4", + "const-oid 0.9.6", + "crypto-common 0.1.7", +] + +[[package]] +name = "digest" +version = "0.11.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2" +dependencies = [ + "block-buffer 0.12.1", + "const-oid 0.10.2", + "crypto-common 0.2.2", + "ctutils", +] + +[[package]] +name = "dirs" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e" +dependencies = [ + "dirs-sys", +] + +[[package]] +name = "dirs-sys" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab" +dependencies = [ + "libc", + "option-ext", + "redox_users", + "windows-sys 0.61.2", +] + +[[package]] +name = "dispatch2" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1e0e367e4e7da84520dedcac1901e4da967309406d1e51017ae1abfb97adbd38" +dependencies = [ + "bitflags", + "objc2", +] + +[[package]] +name = "displaydoc" +version = "0.2.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6232dd377dcc64799954cbd3a9bb882e9cdc1308ccd87b1c098f1fb2eaf82a8" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "document-features" +version = "0.2.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61" +dependencies = [ + "litrs", +] + +[[package]] +name = "dunce" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" + +[[package]] +name = "either" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e9c71c2167ca323c882b99918929403426e2373ea17242ff5653e0d5e1058be" + +[[package]] +name = "encode_unicode" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" + +[[package]] +name = "equivalent" +version = "1.0.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826" + +[[package]] +name = "errno" +version = "0.3.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "fastrand" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223" + +[[package]] +name = "filetime" +version = "0.2.29" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c287a33c7f0a620c38e641e7f60827713987b3c0f26e8ddc9462cc69cf75759" +dependencies = [ + "cfg-if", + "libc", +] + +[[package]] +name = "find-msvc-tools" +version = "0.1.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c66915cc5391097de7a2b0b972e8505aa33c0df401fd3a6811dbdb32881ba48" + +[[package]] +name = "flate2" +version = "1.1.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "626d4928326b646e70f65ed36fc7cf9f206bdb68a0019ee7c6b4709da4e084c4" +dependencies = [ + "zlib-rs", +] + +[[package]] +name = "fnv" +version = "1.0.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" + +[[package]] +name = "foldhash" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" + +[[package]] +name = "form_urlencoded" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf" +dependencies = [ + "percent-encoding", +] + +[[package]] +name = "fs_extra" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" + +[[package]] +name = "fundu" +version = "2.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e47ed3102262b937cdbc46cc412c58f2243b8d13989657d0c9f027eb03168aca" +dependencies = [ + "fundu-core", +] + +[[package]] +name = "fundu-core" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "358c273f0d54362c071e0d60af2ed872c264697ceccaa8e43b73abc508142830" + +[[package]] +name = "futures" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9a31d2a3fbaaeb2af2368bbdd904aa8e812d3c04a1ee10d3171f52d556e5d0a3" +dependencies = [ + "futures-channel", + "futures-core", + "futures-executor", + "futures-io", + "futures-sink", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-channel" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b1f9e3d69d39e4862ffed03ed071a76f9a13ba1d9109d355b0f0aa6b15e393c4" +dependencies = [ + "futures-core", + "futures-sink", +] + +[[package]] +name = "futures-core" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92d699e522242e69e3003b94ecc1f960f3a5e015aa7c5d7486e65ad01dd94f5e" + +[[package]] +name = "futures-executor" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "031b47cf1a3c6cc8bc2fc76cd437f521619387907d469316e7c0bc278f1f5432" +dependencies = [ + "futures-core", + "futures-task", + "futures-util", +] + +[[package]] +name = "futures-io" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "53c0fa8157de1303bfffdaa1cc2a673bfffb60102f76b0ef4441659124373fed" + +[[package]] +name = "futures-macro" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9fb9654ba8355388abeb8dcb4fc62f511300867002afc858860463bdd9fe0c44" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "futures-sink" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1944426bf7d03f1d14f708785e4b33efd750b36d48a157b836b3efc15ede8e1d" + +[[package]] +name = "futures-task" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cd417de3d1d015fc3bfd2b1ea46dfc7bab72ef86f1cc7cc9c78e728b34a6d1fd" + +[[package]] +name = "futures-util" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0d50a92467f8ba5dd6e3ee5d4bd04d73ab2e4e1c44474a0674821dfce14b79bc" +dependencies = [ + "futures-channel", + "futures-core", + "futures-io", + "futures-macro", + "futures-sink", + "futures-task", + "memchr", + "pin-project-lite", + "slab", +] + +[[package]] +name = "generic-array" +version = "0.14.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" +dependencies = [ + "typenum", + "version_check", +] + +[[package]] +name = "getrandom" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "wasi", + "wasm-bindgen", +] + +[[package]] +name = "getrandom" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099" +dependencies = [ + "cfg-if", + "js-sys", + "libc", + "r-efi", + "rand_core 0.10.1", + "wasm-bindgen", +] + +[[package]] +name = "ghash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1" +dependencies = [ + "opaque-debug", + "polyval", +] + +[[package]] +name = "glob" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e4eba85ea1d0a966a983acd07deee566e67395d2d96b6fb39e62b5a833f1eb0b" + +[[package]] +name = "h2" +version = "0.4.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7d29020232d6aa3fb1daca64c1127cf662cf97f254ae16c18c05b8ab635fc118" +dependencies = [ + "atomic-waker", + "bytes", + "fnv", + "futures-core", + "futures-sink", + "http", + "indexmap", + "slab", + "tokio", + "tokio-util", + "tracing", +] + +[[package]] +name = "hashbrown" +version = "0.17.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a" +dependencies = [ + "foldhash", +] + +[[package]] +name = "heck" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" + +[[package]] +name = "hex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" + +[[package]] +name = "hmac" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6303bc9732ae41b04cb554b844a762b4115a61bfaa81e3e83050991eeb56863f" +dependencies = [ + "digest 0.11.3", +] + +[[package]] +name = "http" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "918d3568bebf352712bc2ef3d46a8bcf1a75b373be6539de198e9105cbbf9ce0" +dependencies = [ + "bytes", + "itoa", +] + +[[package]] +name = "http-body" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca2a8f2913ee65f60facd6a5905613afaa448497a0230cc41ce022d93290bc2c" +dependencies = [ + "bytes", + "http", +] + +[[package]] +name = "http-body-util" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "23169fe34a5fbcdd3f3862e78fb9b6fccd5f02a6dc6f732547005d45631ce71c" +dependencies = [ + "bytes", + "futures-core", + "http", + "http-body", + "pin-project-lite", +] + +[[package]] +name = "httparse" +version = "1.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87" + +[[package]] +name = "humansize" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6cb51c9a029ddc91b07a787f1d86b53ccfa49b0e86688c946ebe8d3555685dd7" +dependencies = [ + "libm", +] + +[[package]] +name = "hybrid-array" +version = "0.4.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17" +dependencies = [ + "typenum", +] + +[[package]] +name = "hyper" +version = "1.12.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c3e324da4c95177d6291d4c8730197c0d1822f8a9766814a4a44fa5ab797c9c" +dependencies = [ + "atomic-waker", + "bytes", + "futures-channel", + "futures-core", + "h2", + "http", + "http-body", + "httparse", + "itoa", + "pin-project-lite", + "smallvec", + "tokio", + "want", +] + +[[package]] +name = "hyper-rustls" +version = "0.27.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dfa8e654703247911e29c23fbeaa261834bd9bb74efba2f9acddc37bfb127f53" +dependencies = [ + "http", + "hyper", + "hyper-util", + "rustls", + "rustls-native-certs", + "tokio", + "tokio-rustls", + "tower-service", + "webpki-roots", +] + +[[package]] +name = "hyper-util" +version = "0.1.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ddc03d96684f9226b8a787cdb71488417b53ab5ea8fdb1dac946cb9431cc8bff" +dependencies = [ + "base64 0.23.1", + "bytes", + "futures-channel", + "futures-util", + "http", + "http-body", + "httparse", + "hyper", + "ipnet", + "libc", + "percent-encoding", + "pin-project-lite", + "socket2", + "tokio", + "tower-service", + "tracing", +] + +[[package]] +name = "icu_collections" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe090a42a0d3140fed8c63263ed1fecc02422cb2f4bfe55cd8de2de1b8e105dd" +dependencies = [ + "displaydoc", + "potential_utf", + "utf8_iter", + "yoke", + "zerofrom", + "zerovec", +] + +[[package]] +name = "icu_locale_core" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "25d29b57c17c6528d0dc4c2141cfa2d08200465acb537a3909c8b9b8a4a984c0" +dependencies = [ + "displaydoc", + "litemap", + "tinystr", + "writeable", + "zerovec", +] + +[[package]] +name = "icu_normalizer" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "404a3b8c486f205c87fe7f23ab6894d84a4ad76d6e4671ae1981ba7def87c599" +dependencies = [ + "icu_collections", + "icu_normalizer_data", + "icu_properties", + "icu_provider", + "smallvec", + "zerovec", +] + +[[package]] +name = "icu_normalizer_data" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20f0088bfb7441f7a37fa0c9e20cb1e9cba1cac6b9ce8cd2a6dc44294f8e8cbc" + +[[package]] +name = "icu_properties" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ea83d991c56158f7cf898bf86436c1dfe7c07ee82fe88951f2695c9f37a379f" +dependencies = [ + "displaydoc", + "icu_collections", + "icu_locale_core", + "icu_properties_data", + "icu_provider", + "zerotrie", + "zerovec", +] + +[[package]] +name = "icu_properties_data" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b98f29af82d02b163fe50161388350e743bb3107cc8e8c2f7314cb505faddfcf" + +[[package]] +name = "icu_provider" +version = "2.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413099315636c588ee8f011190b329b971a09a8fae9d157e01dcae8379468514" +dependencies = [ + "displaydoc", + "icu_locale_core", + "writeable", + "yoke", + "zerofrom", + "zerotrie", + "zerovec", +] + +[[package]] +name = "ident_case" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" + +[[package]] +name = "idna" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de" +dependencies = [ + "idna_adapter", + "smallvec", + "utf8_iter", +] + +[[package]] +name = "idna_adapter" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb68373c0d6620ef8105e855e7745e18b0d00d3bdb07fb532e434244cdb9a714" +dependencies = [ + "icu_normalizer", + "icu_properties", +] + +[[package]] +name = "indexmap" +version = "2.14.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cc4e190f5d26ca7051642629da2c52fc03bde85a03197c99408dcd291734c855" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "indicatif" +version = "0.18.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9433806cd6b4ec1aba79c021c7e4c58fb4c3b9977c085062e611ac929998fb0c" +dependencies = [ + "console", + "portable-atomic", + "unicode-width", + "unit-prefix", + "web-time", +] + +[[package]] +name = "inout" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01" +dependencies = [ + "generic-array", +] + +[[package]] +name = "ipnet" +version = "2.12.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "791930b43c0d5973160d90a8f3894509f2b273430f5c5c73b668636d0287c5c0" + +[[package]] +name = "is_terminal_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695" + +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + +[[package]] +name = "itoa" +version = "1.0.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3bd1574e617a9a6c1f8f8181bd7e841e1f20e4277607ef28945765188d6284d4" + +[[package]] +name = "jiff" +version = "0.2.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fcefdcefac59ac8f8401852e3427d55610481fc41e6625c39bac62d2d771623a" +dependencies = [ + "jiff-core", + "jiff-static", + "jiff-tzdb-platform", + "log", + "portable-atomic", + "portable-atomic-util", + "serde_core", + "windows-link", +] + +[[package]] +name = "jiff-core" +version = "0.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77a24020db0ee88d1c681d677681bd31f9f4ea189a455425223d52ce4f1508aa" +dependencies = [ + "log", +] + +[[package]] +name = "jiff-static" +version = "0.2.41" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "203edf9b0ce4083ec8fbf4adc823eac89768ea994b4953fc0dab1b90083234dd" +dependencies = [ + "jiff-core", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "jiff-tzdb" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fa8377070c6bae868759445e5a77f66d84f0b72f3a054bfb00e6d038b8282da7" + +[[package]] +name = "jiff-tzdb-platform" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8" +dependencies = [ + "jiff-tzdb", +] + +[[package]] +name = "jobserver" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3" +dependencies = [ + "getrandom 0.4.3", + "libc", +] + +[[package]] +name = "js-sys" +version = "0.3.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8dc09d2154098bbf4ef54eab6b117a3c24cbbffe94046b16ee6d6d4510584d3a" +dependencies = [ + "cfg-if", + "futures-util", + "wasm-bindgen", +] + +[[package]] +name = "lazy_static" +version = "1.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "20870f649af7073d53e38067b2a84312175d56ea15217e1b15bc83506ec50afb" +dependencies = [ + "spin 0.9.9", +] + +[[package]] +name = "libc" +version = "0.2.191" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a" + +[[package]] +name = "libloading" +version = "0.8.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55" +dependencies = [ + "cfg-if", + "windows-link", +] + +[[package]] +name = "libm" +version = "0.2.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981" + +[[package]] +name = "libredox" +version = "0.1.25" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61ff90caf6077a803a240f62fdbe88645a890bbca49ef8174c3cb0404362171d" +dependencies = [ + "libc", +] + +[[package]] +name = "linux-raw-sys" +version = "0.12.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" + +[[package]] +name = "litemap" +version = "0.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d9d19d1d6efa0109d2f65ff4c85cddd50bd572e5a00127ab10987290bcefae" + +[[package]] +name = "litrs" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4744e383959f0db86ede514b809b1c53251889093803c05267acc7d4e7030d70" + +[[package]] +name = "lock_api" +version = "0.4.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "lock_api" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65d91b22da179613dcf4d6ec8349563f52a363f6849e03b00dd0a185ec4a59af" +dependencies = [ + "scopeguard", +] + +[[package]] +name = "log" +version = "0.4.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5d15f86d12da44cd8d4ec3c73984537eb7f4cadcb9776a575a0a8a05ca11005c" + +[[package]] +name = "lru" +version = "0.18.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef9ac18847474e638e3702b76c65d4eb93428471a74778ef0f1be711717f89b5" +dependencies = [ + "hashbrown", +] + +[[package]] +name = "lru-slab" +version = "0.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4050469837a6ff301cd14c1f8f24f88549e6d548f24f64e2148eb0f72cebc51f" + +[[package]] +name = "matchers" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9" +dependencies = [ + "regex-automata", +] + +[[package]] +name = "md-5" +version = "0.10.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" +dependencies = [ + "cfg-if", + "digest 0.10.7", +] + +[[package]] +name = "md-5" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69b6441f590336821bb897fb28fc622898ccceb1d6cea3fde5ea86b090c4de98" +dependencies = [ + "cfg-if", + "digest 0.11.3", +] + +[[package]] +name = "memchr" +version = "2.8.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" + +[[package]] +name = "memmap2" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b0ca1155a9ecc25aa12e8313a119f32edf0255fea2f44839c4ac0a12b2ac157" +dependencies = [ + "libc", +] + +[[package]] +name = "mime" +version = "0.3.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d5848f5a9e8117cf94f2f90faac24a87ff81600ff8628c1e3deaab572e76bfa1" + +[[package]] +name = "mime_guess" +version = "2.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e" +dependencies = [ + "mime", + "unicase", +] + +[[package]] +name = "minimal-lexical" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" + +[[package]] +name = "mio" +version = "1.2.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1788edb87fdc09c7e26304471e2f5be8cdefb1b6930d6e3985fc02ff53bf86ee" +dependencies = [ + "libc", + "wasi", + "windows-sys 0.61.2", +] + +[[package]] +name = "nix" +version = "0.31.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf20d2fde8ff38632c426f1165ed7436270b44f199fc55284c38276f9db47c3d" +dependencies = [ + "bitflags", + "cfg-if", + "cfg_aliases", + "libc", +] + +[[package]] +name = "nixl-sys" +version = "1.6.0" +source = "git+https://github.com/houseme/nixl?rev=cc636c83f13d692e85b67e55aed092413d16fb41#cc636c83f13d692e85b67e55aed092413d16fb41" +dependencies = [ + "anyhow", + "bindgen", + "cc", + "libc", + "os_info", + "pkg-config", + "serde", + "thiserror", + "tracing", + "wincode", +] + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "nu-ansi-term" +version = "0.50.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "num-bigint" +version = "0.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-bigint-dig" +version = "0.8.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e661dda6640fad38e827a6d4a310ff4763082116fe217f279885c97f511bb0b7" +dependencies = [ + "lazy_static", + "libm", + "num-integer", + "num-iter", + "num-traits", + "rand 0.8.8", + "smallvec", + "zeroize", +] + +[[package]] +name = "num-conv" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "521739c6d2bac4aa25192232afe6841231376b2b26d4d9fae5ecf8ca5772e441" + +[[package]] +name = "num-integer" +version = "0.1.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ce2d95d4b3734dc35aa2f45e1aa22cd416814592a4f9d9205e11affd5b8e10b" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-iter" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c92800bd69a1eac91786bcfe9da64a897eb72911b8dc3095decbd07429e8048b" +dependencies = [ + "num-integer", + "num-traits", +] + +[[package]] +name = "num-traits" +version = "0.2.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841" +dependencies = [ + "autocfg", + "libm", +] + +[[package]] +name = "objc2" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "08849bbd4767dfae9457696856ae1c84fe4e0281bbe4a7abff2d0e06fb7981f8" +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", + "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" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536" +dependencies = [ + "bitflags", + "dispatch2", + "objc2", +] + +[[package]] +name = "objc2-core-graphics" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e022c9d066895efa1345f8e33e584b9f958da2fd4cd116792e15e07e4720a807" +dependencies = [ + "bitflags", + "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", + "objc2", + "objc2-core-foundation", + "objc2-core-graphics", +] + +[[package]] +name = "objc2-encode" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33" + +[[package]] +name = "objc2-foundation" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3e0adef53c21f888deb4fa59fc59f7eb17404926ee8a6f59f5df0fd7f9f3272" +dependencies = [ + "bitflags", + "block2", + "libc", + "objc2", + "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", + "objc2", + "objc2-core-foundation", +] + +[[package]] +name = "objc2-quartz-core" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f" +dependencies = [ + "bitflags", + "objc2", + "objc2-core-foundation", + "objc2-foundation", +] + +[[package]] +name = "objc2-ui-kit" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d87d638e33c06f577498cbcc50491496a3ed4246998a7fbba7ccb98b1e7eab22" +dependencies = [ + "bitflags", + "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 = "oid-registry" +version = "0.8.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "12f40cff3dde1b6087cc5d5f5d4d65712f34016a03ed60e9c08dcc392736b5b7" +dependencies = [ + "asn1-rs", +] + +[[package]] +name = "once_cell" +version = "1.21.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50" + +[[package]] +name = "once_cell_polyfill" +version = "1.70.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe" + +[[package]] +name = "opaque-debug" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381" + +[[package]] +name = "openssl-probe" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e036b411754132fd6b74e94b74e9a13c5cf606fa93d1885c35860d3060820b1" + +[[package]] +name = "option-ext" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d" + +[[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", + "objc2", + "objc2-foundation", + "objc2-ui-kit", + "serde", + "windows-sys 0.61.2", +] + +[[package]] +name = "outref" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1a80800c0488c3a21695ea981a54918fbb37abf04f4d0720c453632255e2ff0e" + +[[package]] +name = "parking_lot" +version = "0.12.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a" +dependencies = [ + "lock_api 0.4.14", + "parking_lot_core 0.9.12", +] + +[[package]] +name = "parking_lot" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a9cf937ca4e1d0b7578784559063422fc39ae7c5a00f02471f2614d5486fd226" +dependencies = [ + "lock_api 0.5.0", + "parking_lot_core 0.10.0", +] + +[[package]] +name = "parking_lot_core" +version = "0.9.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1" +dependencies = [ + "cfg-if", + "libc", + "redox_syscall 0.5.18", + "smallvec", + "windows-link", +] + +[[package]] +name = "parking_lot_core" +version = "0.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cfff060068cc18aa7815010fcaf80c68c7fb9e85fc7f5c0f9bf142c21d19826" +dependencies = [ + "libc", + "redox_syscall 0.9.5", + "smallvec", + "windows-link", +] + +[[package]] +name = "pastey" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ee67f1008b1ba2321834326597b8e186293b049a023cdef258527550b9935b4" + +[[package]] +name = "pem-rfc7468" +version = "0.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412" +dependencies = [ + "base64ct", +] + +[[package]] +name = "percent-encoding" +version = "2.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" + +[[package]] +name = "pin-project-lite" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd" + +[[package]] +name = "pkcs1" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c8ffb9f10fa047879315e6625af03c164b16962a5368d724ed16323b68ace47f" +dependencies = [ + "der", + "pkcs8", + "spki", +] + +[[package]] +name = "pkcs8" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" +dependencies = [ + "der", + "spki", +] + +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + +[[package]] +name = "polyval" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "opaque-debug", + "universal-hash", +] + +[[package]] +name = "portable-atomic" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85" + +[[package]] +name = "portable-atomic-util" +version = "0.2.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "10ab3eb7f3becc3a1cbc4f2c6f20267996cfc1a6467a873763411b136a122715" +dependencies = [ + "portable-atomic", +] + +[[package]] +name = "potential_utf" +version = "0.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d83eb9bc6d8e5cf568e7a1101d60ee05e81ed50ea106026f3d18deeb046d7661" +dependencies = [ + "zerovec", +] + +[[package]] +name = "powerfmt" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a6394b9e965e73d0a289ee54f589087e2c676aedf60885baf52c76b771e4958" + +[[package]] +name = "ppv-lite86" +version = "0.2.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9" +dependencies = [ + "zerocopy", +] + +[[package]] +name = "prettyplease" +version = "0.2.37" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" +dependencies = [ + "proc-macro2", + "syn 2.0.119", +] + +[[package]] +name = "proc-macro2" +version = "1.0.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quick-xml" +version = "0.41.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e660451e55124f798a69a5af3f49ccfbefbd41910eefd25caf2393e1f3473ec1" +dependencies = [ + "memchr", + "serde", +] + +[[package]] +name = "quinn" +version = "0.11.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4051e23e9185c255a7e33ef59cdbca87a22d359052eecd22fc6b901fb37d9d11" +dependencies = [ + "bytes", + "cfg_aliases", + "pin-project-lite", + "quinn-proto", + "quinn-udp", + "rustc-hash", + "rustls", + "socket2", + "thiserror", + "tokio", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-proto" +version = "0.11.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e750cca55fe4f0439a15d0bb529da9651e79993e8e72c61a899a36d462befbe" +dependencies = [ + "bytes", + "getrandom 0.4.3", + "lru-slab", + "rand 0.10.3", + "rand_pcg", + "ring", + "rustc-hash", + "rustls", + "rustls-pki-types", + "slab", + "thiserror", + "tinyvec", + "tracing", + "web-time", +] + +[[package]] +name = "quinn-udp" +version = "0.5.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af66907df18639dcf4db56ca65490cabc4b27a97dbadd96f2926cca73298f016" +dependencies = [ + "cfg_aliases", + "libc", + "once_cell", + "socket2", + "tracing", + "windows-sys 0.61.2", +] + +[[package]] +name = "quote" +version = "1.0.47" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "r-efi" +version = "6.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf" + +[[package]] +name = "rand" +version = "0.8.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e058c7de0b26af77780c769414d6257830bb240f3c38477dbc2c16e5f54d6d4c" +dependencies = [ + "libc", + "rand_chacha", + "rand_core 0.6.4", +] + +[[package]] +name = "rand" +version = "0.10.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "65c9fb96cbc91e3478eaae79a69fcd3f1ae4ad052e471fe6732fff548984b4af" +dependencies = [ + "chacha20", + "getrandom 0.4.3", + "rand_core 0.10.1", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core 0.6.4", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom 0.2.17", +] + +[[package]] +name = "rand_core" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69" + +[[package]] +name = "rand_pcg" +version = "0.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "caa0f4137e1c0a72f4c651489402276c8e8e1cf081f3b0ba156d2cbeef09e86a" +dependencies = [ + "rand_core 0.10.1", +] + +[[package]] +name = "rc-core" +version = "0.1.39" +dependencies = [ + "aes-gcm", + "anyhow", + "async-trait", + "base64 0.22.1", + "dirs", + "futures", + "getrandom 0.4.3", + "glob", + "hex", + "http", + "humansize", + "jiff", + "rand 0.8.8", + "rsa", + "rustls-pki-types", + "serde", + "serde_json", + "sha2 0.10.9", + "tar", + "tempfile", + "thiserror", + "tokio", + "toml", + "tracing", + "url", + "urlencoding", + "x509-parser", + "zeroize", +] + +[[package]] +name = "rc-s3" +version = "0.1.39" +dependencies = [ + "anyhow", + "async-trait", + "aws-config", + "aws-credential-types", + "aws-sdk-s3", + "aws-sigv4", + "aws-smithy-checksums", + "aws-smithy-runtime-api", + "aws-smithy-types", + "base64 0.22.1", + "bytes", + "futures", + "hex", + "http", + "http-body", + "http-body-util", + "jiff", + "md-5 0.10.6", + "quick-xml", + "rc-core", + "reqwest", + "serde", + "serde_json", + "sha2 0.10.9", + "tempfile", + "thiserror", + "tokio", + "tracing", + "url", + "urlencoding", + "zeroize", +] + +[[package]] +name = "redox_syscall" +version = "0.5.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d" +dependencies = [ + "bitflags", +] + +[[package]] +name = "redox_syscall" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "580c875845b41ecb1564ad1ae4703044cef774145e3d7a94dc2b3fa7c97868fd" +dependencies = [ + "bitflags", +] + +[[package]] +name = "redox_users" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60dc65c0ff1a7ae1294b0c67b9f14baf70b644404010370171787bfac1038fc0" +dependencies = [ + "libredox", + "thiserror", +] + +[[package]] +name = "regex" +version = "1.13.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f020237b6c8eed93db2e2cb53c00c60a8e1bc73da7d073199a1180401450218d" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.18" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ad8553b9b26413251cbf30e620595c7a41b3887f03da04579c0e6b0d6a06b4b2" +dependencies = [ + "aho-corasick", + "memchr", + "regex-syntax", +] + +[[package]] +name = "regex-lite" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab834c73d247e67f4fae452806d17d3c7501756d98c8808d7c9c7aa7d18f973" + +[[package]] +name = "regex-syntax" +version = "0.8.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4" + +[[package]] +name = "reqwest" +version = "0.12.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eddd3ca559203180a307f12d114c268abf583f59b03cb906fd0b3ff8646c1147" +dependencies = [ + "base64 0.22.1", + "bytes", + "futures-core", + "futures-util", + "http", + "http-body", + "http-body-util", + "hyper", + "hyper-rustls", + "hyper-util", + "js-sys", + "log", + "percent-encoding", + "pin-project-lite", + "quinn", + "rustls", + "rustls-native-certs", + "rustls-pki-types", + "serde", + "serde_json", + "serde_urlencoded", + "sync_wrapper", + "tokio", + "tokio-rustls", + "tokio-util", + "tower", + "tower-http", + "tower-service", + "url", + "wasm-bindgen", + "wasm-bindgen-futures", + "wasm-streams", + "web-sys", + "webpki-roots", +] + +[[package]] +name = "ring" +version = "0.17.14" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7" +dependencies = [ + "cc", + "cfg-if", + "getrandom 0.2.17", + "libc", + "untrusted", + "windows-sys 0.52.0", +] + +[[package]] +name = "rsa" +version = "0.9.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b8573f03f5883dcaebdfcf4725caa1ecb9c15b2ef50c43a07b816e06799bb12d" +dependencies = [ + "const-oid 0.9.6", + "digest 0.10.7", + "num-bigint-dig", + "num-integer", + "num-traits", + "pkcs1", + "pkcs8", + "rand_core 0.6.4", + "sha2 0.10.9", + "signature", + "spki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustc-hash" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6b1e7f9a428571be2dc5bc0505c13fb6bf936822b894ec87abf8a08a4e51742d" + +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + +[[package]] +name = "rustfs-cli" +version = "0.1.39" +dependencies = [ + "anyhow", + "async-trait", + "clap", + "clap_complete", + "comfy-table", + "console", + "fundu", + "futures", + "glob", + "humansize", + "indicatif", + "jiff", + "mime_guess", + "quick-xml", + "rc-core", + "rc-s3", + "serde", + "serde_json", + "shlex 1.3.0", + "tempfile", + "thiserror", + "tokio", + "tracing", + "tracing-subscriber", + "url", + "urlencoding", + "zeroize", + "zip", +] + +[[package]] +name = "rustfs-cli-nixl" +version = "0.1.0" +dependencies = [ + "async-trait", + "base64 0.22.1", + "getrandom 0.4.3", + "http", + "rc-core", + "rc-s3", + "rustfs-cli", + "rustfs-nixl", + "tokio", +] + +[[package]] +name = "rustfs-nixl" +version = "1.0.5" +source = "git+https://github.com/rustfs/rustfs?rev=b86624520c99de06d9e36b971520a7071ca54b4c#b86624520c99de06d9e36b971520a7071ca54b4c" +dependencies = [ + "base64-simd", + "bytes", + "memmap2", + "nixl-sys", + "parking_lot 0.13.0", + "thiserror", + "tokio", + "tracing", +] + +[[package]] +name = "rusticata-macros" +version = "4.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "faf0c4a6ece9950b9abdb62b1cfcf2a68b3b67a10ba445b3bb85be2a293d0632" +dependencies = [ + "nom", +] + +[[package]] +name = "rustix" +version = "1.1.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5e76742e5294153d4dde1207dbec5bdd81eef6fabdc0d2118babadabfd858aa" +dependencies = [ + "bitflags", + "errno", + "libc", + "linux-raw-sys", + "windows-sys 0.61.2", +] + +[[package]] +name = "rustls" +version = "0.23.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48e13bd8c0e9365c43cfa5c9e8f9ad49d3c8444926c9aac819e0e4dc503c8fdf" +dependencies = [ + "aws-lc-rs", + "once_cell", + "ring", + "rustls-pki-types", + "rustls-webpki", + "subtle", + "zeroize", +] + +[[package]] +name = "rustls-native-certs" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4a073f5dc7469f984c52ad2752b63b0807745133b6de880b7b64c1ac4c48aec4" +dependencies = [ + "openssl-probe", + "rustls-pki-types", + "schannel", + "security-framework", +] + +[[package]] +name = "rustls-pki-types" +version = "1.15.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2f4925028c7eb5d1fcdaf196971378ed9d2c1c4efc7dc5d011256f76c99c0a96" +dependencies = [ + "web-time", + "zeroize", +] + +[[package]] +name = "rustls-webpki" +version = "0.103.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4443b1b6d39d7c663139942cc4558262562d2c84123bb6282ef177009ca8b281" +dependencies = [ + "aws-lc-rs", + "ring", + "rustls-pki-types", + "untrusted", +] + +[[package]] +name = "rustversion" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f" + +[[package]] +name = "ryu" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f" + +[[package]] +name = "schannel" +version = "0.1.30" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9cb23c424d8ee841bb4d813677ca237e2a610067d594fec130f87d6093495ab5" +dependencies = [ + "windows-sys 0.61.2", +] + +[[package]] +name = "scopeguard" +version = "1.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" + +[[package]] +name = "security-framework" +version = "3.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d" +dependencies = [ + "bitflags", + "core-foundation", + "core-foundation-sys", + "libc", + "security-framework-sys", +] + +[[package]] +name = "security-framework-sys" +version = "2.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3" +dependencies = [ + "core-foundation-sys", + "libc", +] + +[[package]] +name = "semver" +version = "1.0.28" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" + +[[package]] +name = "serde" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba" +dependencies = [ + "serde_core", + "serde_derive", +] + +[[package]] +name = "serde_core" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.229" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "serde_json" +version = "1.0.154" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6" +dependencies = [ + "itoa", + "memchr", + "serde", + "serde_core", + "zmij", +] + +[[package]] +name = "serde_spanned" +version = "1.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c187e0a369471c550af028cba56d4f4fa2a489ad28151ae95a4d340a2a8b782" +dependencies = [ + "serde_core", +] + +[[package]] +name = "serde_urlencoded" +version = "0.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" +dependencies = [ + "form_urlencoded", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "sha1" +version = "0.10.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a978451301f4db1d02937a4ab3ccce137717b81826e79b7d49ffe3244a13c3b8" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest 0.10.7", +] + +[[package]] +name = "sha1" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.1", + "digest 0.11.3", +] + +[[package]] +name = "sha2" +version = "0.10.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283" +dependencies = [ + "cfg-if", + "cpufeatures 0.2.17", + "digest 0.10.7", +] + +[[package]] +name = "sha2" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "47d7069beb7d6ac7b9acd1039986e73443f24234f41074da099d6f994ac9ad19" +dependencies = [ + "cfg-if", + "cpufeatures 0.3.1", + "digest 0.11.3", +] + +[[package]] +name = "sharded-slab" +version = "0.1.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" +dependencies = [ + "lazy_static", +] + +[[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" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba" + +[[package]] +name = "signal-hook-registry" +version = "1.4.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b" +dependencies = [ + "errno", + "libc", +] + +[[package]] +name = "signature" +version = "2.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" +dependencies = [ + "digest 0.10.7", + "rand_core 0.6.4", +] + +[[package]] +name = "simd-adler32" +version = "0.3.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a219298ac11a56ea9a6d2120044824d6f01aeb034955e7af7bc16858527deea" + +[[package]] +name = "slab" +version = "0.4.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5" + +[[package]] +name = "smallvec" +version = "1.16.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "149309498a5f7334b12ddae0cad8aba81ce785fe91755068867e017cf98fee46" + +[[package]] +name = "socket2" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3d1e2c7f27f8d4cb10542a02c49005dbd6e93095799d6f3be745fae9f8fedd4" +dependencies = [ + "libc", + "windows-sys 0.61.2", +] + +[[package]] +name = "spin" +version = "0.9.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3763264f6b73151db08c50ff20d7d8a0b8796e021cdea7ceedad07b80155fa0e" + +[[package]] +name = "spin" +version = "0.10.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "023a211cb3138dbc438680b32560ad89f699977624c9f8dbb95a47d5b4c07dd3" + +[[package]] +name = "spki" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" +dependencies = [ + "base64ct", + "der", +] + +[[package]] +name = "stable_deref_trait" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" + +[[package]] +name = "strsim" +version = "0.11.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f" + +[[package]] +name = "subtle" +version = "2.6.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292" + +[[package]] +name = "syn" +version = "2.0.119" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "3.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ae9ccbea3a7b0b09443036490c8f34a8b1b760fd345e5c0dae0aac718faea79" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "sync_wrapper" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" +dependencies = [ + "futures-core", +] + +[[package]] +name = "synstructure" +version = "0.13.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "synstructure" +version = "0.14.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "901704edd0dfe137f1987838ee4f259e4e063c31371bdb423f7ae38ec6f77f02" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "tar" +version = "0.4.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3f6221d9a6003c78398e3b239969f352578258df48c8eb051caadae0015bc840" +dependencies = [ + "filetime", + "libc", + "xattr", +] + +[[package]] +name = "tempfile" +version = "3.27.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd" +dependencies = [ + "fastrand", + "getrandom 0.4.3", + "once_cell", + "rustix", + "windows-sys 0.61.2", +] + +[[package]] +name = "thiserror" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09e52cb86a36cede5cb101bf8908837b3e4c6e5e59fe7fd85c23fb56200d189e" +dependencies = [ + "thiserror-impl", +] + +[[package]] +name = "thiserror-impl" +version = "2.0.21" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe5197923287db20a58125f0bc85c062f7f2c892de97b18c356f9efb14b28524" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "thread_local" +version = "1.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1ad99c4c6d32803332c548b1af0540b357b3f5fc0be8f6c6bfe8b2e6ae784070" +dependencies = [ + "cfg-if", +] + +[[package]] +name = "time" +version = "0.3.55" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb87b95ec50ddfa440816d227a17b2ccbdda963a316a727fda0fc4334f7d134" +dependencies = [ + "deranged", + "num-conv", + "powerfmt", + "serde_core", + "time-core", + "time-macros", +] + +[[package]] +name = "time-core" +version = "0.1.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109" + +[[package]] +name = "time-macros" +version = "0.2.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7e689342a48d2ea927c87ea50cabf8594854bf940e9310208848d680d668ed85" +dependencies = [ + "num-conv", + "time-core", +] + +[[package]] +name = "tinystr" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "abc840c238154d58f9e86b2792261edfde565a17696e1cda1a449de27979801a" +dependencies = [ + "displaydoc", + "zerovec", +] + +[[package]] +name = "tinyvec" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fd3ca314f692efd6c868f8408f53fe444634a845f96c028b97d35f6a1f79f0ee" + +[[package]] +name = "tokio" +version = "1.54.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b52fd3255258d26fac7264ab5a76b53c13367136dc011d3d6ad4f8ed070396a3" +dependencies = [ + "bytes", + "libc", + "mio", + "parking_lot 0.12.5", + "pin-project-lite", + "signal-hook-registry", + "socket2", + "tokio-macros", + "windows-sys 0.61.2", +] + +[[package]] +name = "tokio-macros" +version = "2.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78773a2a397f451582ce068015985c33193cf6dea8b74d2a639fe457b2f07b0e" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "tokio-rustls" +version = "0.26.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c9cc2678c2cdd569ef8215e2afd7954ada2ae20b4fdd2c5fe6139a3b02d105db" +dependencies = [ + "rustls", + "tokio", +] + +[[package]] +name = "tokio-util" +version = "0.7.20" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e464cf451ba96ebfc6f9b6542f17ee8b8956e33f1e40d9690624e59d7a7f8a4b" +dependencies = [ + "bytes", + "futures-core", + "futures-sink", + "libc", + "pin-project-lite", + "tokio", +] + +[[package]] +name = "toml" +version = "0.9.12+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863" +dependencies = [ + "indexmap", + "serde_core", + "serde_spanned", + "toml_datetime", + "toml_parser", + "toml_writer", + "winnow 0.7.15", +] + +[[package]] +name = "toml_datetime" +version = "0.7.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347" +dependencies = [ + "serde_core", +] + +[[package]] +name = "toml_parser" +version = "1.1.5+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baa693a8032d7e1cada7d0041e96126df243179ff061456783ac7f12bda4744c" +dependencies = [ + "winnow 1.0.5", +] + +[[package]] +name = "toml_writer" +version = "1.2.0+spec-1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "009dbb7700f11c55ef83aebbe4c0e9cf1f1ac0844bd8d6f00dc38f302026e13a" + +[[package]] +name = "tower" +version = "0.5.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4" +dependencies = [ + "futures-core", + "futures-util", + "pin-project-lite", + "sync_wrapper", + "tokio", + "tower-layer", + "tower-service", +] + +[[package]] +name = "tower-http" +version = "0.6.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840" +dependencies = [ + "bitflags", + "bytes", + "futures-util", + "http", + "http-body", + "pin-project-lite", + "tower", + "tower-layer", + "tower-service", + "url", +] + +[[package]] +name = "tower-layer" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e" + +[[package]] +name = "tower-service" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3" + +[[package]] +name = "tracing" +version = "0.1.44" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100" +dependencies = [ + "pin-project-lite", + "tracing-attributes", + "tracing-core", +] + +[[package]] +name = "tracing-attributes" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "tracing-core" +version = "0.1.36" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a" +dependencies = [ + "once_cell", + "valuable", +] + +[[package]] +name = "tracing-log" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3" +dependencies = [ + "log", + "once_cell", + "tracing-core", +] + +[[package]] +name = "tracing-subscriber" +version = "0.3.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319" +dependencies = [ + "matchers", + "nu-ansi-term", + "once_cell", + "regex-automata", + "sharded-slab", + "smallvec", + "thread_local", + "tracing", + "tracing-core", + "tracing-log", +] + +[[package]] +name = "try-lock" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" + +[[package]] +name = "typed-path" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ce898823d8cd0f028662d2f349694b1af0a5cc9be83f1d213a00d3147445e1e" + +[[package]] +name = "typenum" +version = "1.20.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20" + +[[package]] +name = "unicase" +version = "2.10.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "357cc3acc6a036009fd6c973ed009037c732d60d0b4f6c673e9041497482a28f" + +[[package]] +name = "unicode-ident" +version = "1.0.27" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563" + +[[package]] +name = "unicode-segmentation" +version = "1.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c6f5d3c3b1bf09027a88a6bc961fc00497d651009560b5463668dc81b0fa87a8" + +[[package]] +name = "unicode-width" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ca718471876992059f251e33aafc334346ada08042b7661dd1fe313a9bced557" + +[[package]] +name = "unit-prefix" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3" + +[[package]] +name = "universal-hash" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea" +dependencies = [ + "crypto-common 0.1.7", + "subtle", +] + +[[package]] +name = "untrusted" +version = "0.9.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" + +[[package]] +name = "url" +version = "2.5.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed" +dependencies = [ + "form_urlencoded", + "idna", + "percent-encoding", + "serde", +] + +[[package]] +name = "urlencoding" +version = "2.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da" + +[[package]] +name = "utf8_iter" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af3bd9d3e571c26fcce9d033b87ea5ab061b8d2ffe9b7a5675d810d68f03edf0" +dependencies = [ + "utf_types", +] + +[[package]] +name = "utf8parse" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" + +[[package]] +name = "utf_types" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3a3b425286980a367278453f3b6d28cdcb134b574e5a35824a6ff5eebad50bb6" + +[[package]] +name = "uuid" +version = "1.29.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bed99139f7dac9b5cfe5f17be4d66dc7079a34dee1d74bcc77217119240e267c" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "valuable" +version = "0.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65" + +[[package]] +name = "version_check" +version = "0.9.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a" + +[[package]] +name = "vsimd" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c3082ca00d5a5ef149bb8b555a72ae84c9c59f7250f013ac822ac2e49b19c64" + +[[package]] +name = "want" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec4cdd0dd910afe868b7ef477227d8d538b46b3075031afee8a9f2acb0a2ed0b" +dependencies = [ + "try-lock", +] + +[[package]] +name = "wasi" +version = "0.11.1+wasi-snapshot-preview1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b" + +[[package]] +name = "wasm-bindgen" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0181c14ddd6c7b8b0b0132a5f1ea2f32be0d893cd3ea97b6e3b28886b8a3d1c" +dependencies = [ + "cfg-if", + "rustversion", + "wasm-bindgen-macro", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-futures" +version = "0.4.80" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5e14e0327cb5368ad60ccb22d04a9827a693c95a926d8d125e9fa39e0baec501" +dependencies = [ + "js-sys", + "tokio", + "wasm-bindgen", +] + +[[package]] +name = "wasm-bindgen-macro" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "6e931a02a39abdbf66966fc35902b5ed58344750a70885bed4ebb3d8eaf28ed9" +dependencies = [ + "quote", + "wasm-bindgen-macro-support", +] + +[[package]] +name = "wasm-bindgen-macro-support" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2ca4b54280e455bd831e33a6b8e734baf432fe63fbc35c42ac14ce67a043a53a" +dependencies = [ + "bumpalo", + "proc-macro2", + "quote", + "syn 3.0.10", + "wasm-bindgen-shared", +] + +[[package]] +name = "wasm-bindgen-shared" +version = "0.2.130" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3b1f9c3798725016c6ee5f2f57869ec0831e8bbc0ab0310a86e787e97f41389e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "wasm-streams" +version = "0.4.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "15053d8d85c7eccdbefef60f06769760a563c7f0a9d6902a13d35c7800b0ad65" +dependencies = [ + "futures-util", + "js-sys", + "wasm-bindgen", + "wasm-bindgen-futures", + "web-sys", +] + +[[package]] +name = "web-sys" +version = "0.3.107" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d7d179596ff5ec0f6de4db64d54011bde6289cc49603d3a6e4ce3f329207ab88" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "web-time" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb" +dependencies = [ + "js-sys", + "wasm-bindgen", +] + +[[package]] +name = "webpki-roots" +version = "1.0.11" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f5f280bbb2b287bc8e7de7e3852945a0ff50d1bbcb5ed42b6c7a568c546df171" +dependencies = [ + "rustls-pki-types", +] + +[[package]] +name = "winapi" +version = "0.3.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" +dependencies = [ + "winapi-i686-pc-windows-gnu", + "winapi-x86_64-pc-windows-gnu", +] + +[[package]] +name = "winapi-i686-pc-windows-gnu" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" + +[[package]] +name = "winapi-x86_64-pc-windows-gnu" +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", + "wincode-derive", +] + +[[package]] +name = "wincode-derive" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d582d9fc9d813264407a9e16bfa16846ccf15ef032f9bbcd700741bdc00255" +dependencies = [ + "darling", + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "windows-link" +version = "0.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" + +[[package]] +name = "windows-sys" +version = "0.52.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" +dependencies = [ + "windows-targets", +] + +[[package]] +name = "windows-sys" +version = "0.61.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc" +dependencies = [ + "windows-link", +] + +[[package]] +name = "windows-targets" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" +dependencies = [ + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", + "windows_i686_gnullvm", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", +] + +[[package]] +name = "windows_aarch64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" + +[[package]] +name = "windows_aarch64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" + +[[package]] +name = "windows_i686_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" + +[[package]] +name = "windows_i686_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" + +[[package]] +name = "windows_i686_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" + +[[package]] +name = "windows_x86_64_gnu" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" + +[[package]] +name = "windows_x86_64_gnullvm" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" + +[[package]] +name = "windows_x86_64_msvc" +version = "0.52.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" + +[[package]] +name = "winnow" +version = "0.7.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "df79d97927682d2fd8adb29682d1140b343be4ac0f08fd68b7765d9c059d3945" + +[[package]] +name = "winnow" +version = "1.0.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c3b93199df0ab874cdf0c6a94f0a0dc3423fe41f1cafb62b8bd7b1deb277aef" + +[[package]] +name = "writeable" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc" + +[[package]] +name = "x509-parser" +version = "0.18.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d43b0f71ce057da06bc0851b23ee24f3f86190b07203dd8f567d0b706a185202" +dependencies = [ + "asn1-rs", + "data-encoding", + "der-parser", + "lazy_static", + "nom", + "oid-registry", + "rusticata-macros", + "thiserror", + "time", +] + +[[package]] +name = "xattr" +version = "1.7.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "963d6fab92d5504b971dc8bd90ca743c2575e590bc8071ea5bc571598667ae08" +dependencies = [ + "libc", + "rustix", +] + +[[package]] +name = "xmlparser" +version = "0.13.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66fee0b777b0f5ac1c69bb06d361268faafa61cd4682ae064a171c16c433e9e4" + +[[package]] +name = "yoke" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "417ef3fcf6c300b7dbd25c85531a746931c02ad536f3cf4786ed1e88223340b3" +dependencies = [ + "stable_deref_trait", + "yoke-derive", + "zerofrom", +] + +[[package]] +name = "yoke-derive" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec8ebde2db3681e8c9980cc27822030e68752690ddfa9473e739aeb4dbde6d71" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", + "synstructure 0.14.0", +] + +[[package]] +name = "zerocopy" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.8.63" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zerofrom" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ec05a11813ea801ff6d75110ad09cd0824ddba17dfe17128ea0d5f68e6c5272" +dependencies = [ + "zerofrom-derive", +] + +[[package]] +name = "zerofrom-derive" +version = "0.1.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f75b4683f6c7f45248d4d64056a24298c6281e0993356d7d1b4a1a962ef10d4a" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", + "synstructure 0.14.0", +] + +[[package]] +name = "zeroize" +version = "1.9.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e13084392c5e4bc371903e2935a5eaeed24905a7511356b883835e18a78f6879" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3c50655cbb0fe3fc43170059e702f1ce5e19b84cec58dc87b037a09935c2f328" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.119", +] + +[[package]] +name = "zerotrie" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ea269c3bd32f0a32c321907a2ae912ba6f4649bb0fc764a15627e99a7095a3f" +dependencies = [ + "displaydoc", + "yoke", + "zerofrom", +] + +[[package]] +name = "zerovec" +version = "0.11.9" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f58a2799cfe9a1670c7ea8edbd52ef8edb93cb37a7f83bf31ba9e35d9dae6a40" +dependencies = [ + "yoke", + "zerofrom", + "zerovec-derive", +] + +[[package]] +name = "zerovec-derive" +version = "0.11.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3743ddbf47738d929cd1ae2e199d40d0162979dfe31aef8ae646d2bf00bf97a" +dependencies = [ + "proc-macro2", + "quote", + "syn 3.0.10", +] + +[[package]] +name = "zip" +version = "9.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0700e6c427aff64acdbf02e85fbfd946c2ee12319d1af013092f3a2178914ff8" +dependencies = [ + "constant_time_eq", + "crc32fast", + "flate2", + "getrandom 0.4.3", + "indexmap", + "libc", + "memchr", + "nix", + "typed-path", + "windows-sys 0.61.2", + "zeroize", + "zopfli", +] + +[[package]] +name = "zlib-rs" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b268e58e7c693d7c271f93ffc4ba3b380412554231c85bf61ca7af91042a4112" + +[[package]] +name = "zmij" +version = "1.0.23" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" + +[[package]] +name = "zopfli" +version = "0.8.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "aaf7fc5d30c28483d93805c4a5e12b05bbb52407fa67c5f8bd552374cd01fb11" +dependencies = [ + "bumpalo", + "crc32fast", + "log", + "simd-adler32", +] diff --git a/nixl/Cargo.toml b/nixl/Cargo.toml new file mode 100644 index 00000000..15d62978 --- /dev/null +++ b/nixl/Cargo.toml @@ -0,0 +1,25 @@ +[package] +name = "rustfs-cli-nixl" +version = "0.1.0" +edition = "2024" +rust-version = "1.99.0" +license = "MIT OR Apache-2.0" +publish = false + +[workspace] +resolver = "3" + +[[bin]] +name = "rc" +path = "src/main.rs" + +[dependencies] +rustfs-cli = { path = "../crates/cli" } +rc-core = { path = "../crates/core" } +rc-s3 = { path = "../crates/s3" } +rustfs-nixl = { git = "https://github.com/rustfs/rustfs", rev = "b86624520c99de06d9e36b971520a7071ca54b4c", features = ["sys"] } +async-trait = "0.1" +base64 = "0.22" +getrandom = "0.4" +http = "1" +tokio = { version = "1", features = ["io-util", "sync", "time"] } diff --git a/nixl/src/main.rs b/nixl/src/main.rs new file mode 100644 index 00000000..521db613 --- /dev/null +++ b/nixl/src/main.rs @@ -0,0 +1,16 @@ +//! rc with the RustFS native S3-over-NIXL/UCX transport. +#![forbid(unsafe_code)] + +mod pool; +mod transport; +mod wire; + +fn main() { + if let Err(error) = rc_s3::data_transport::install_object_data_transport_factory( + std::sync::Arc::new(transport::Factory), + ) { + eprintln!("{error}"); + std::process::exit(error.exit_code()); + } + rustfs_cli::run(); +} diff --git a/nixl/src/pool.rs b/nixl/src/pool.rs new file mode 100644 index 00000000..c3646f72 --- /dev/null +++ b/nixl/src/pool.rs @@ -0,0 +1,94 @@ +//! Registered host memory and ownership while the server can access it. + +use base64::{Engine, engine::general_purpose::STANDARD}; +use http::HeaderValue; +use rc_core::{Error, Result}; +use rustfs_nixl::{NixlConfig, NixlServer, StagingChunk}; +use std::sync::{Arc, Mutex}; +use std::time::Duration; +use tokio::sync::{Semaphore, SemaphorePermit}; + +pub(crate) const WINDOW: usize = rc_s3::multipart::DEFAULT_PART_SIZE as usize; +pub(crate) const SMALL_WINDOW: usize = 1024 * 1024; +// Two windows allow the next network read to overlap the previous file write. +static AGENTS: Semaphore = Semaphore::const_new(8); +static QUARANTINE: Mutex)>> = Mutex::new(Vec::new()); + +pub(crate) struct Pool { + agent: Arc, + pub(crate) name: HeaderValue, + pub(crate) metadata: HeaderValue, + _budget: SemaphorePermit<'static>, +} + +impl Pool { + pub(crate) fn open(window: usize) -> Result> { + let budget = AGENTS + .try_acquire() + .map_err(|_| Error::General("NIXL registered memory budget exhausted".into()))?; + let id = getrandom::u64() + .map_err(|_| Error::General("Could not generate a NIXL agent ID".into()))?; + let name = format!("rc-{}-{id:016x}", std::process::id()); + let agent = NixlServer::new(&NixlConfig { + agent_name: name.clone(), + chunk_bytes: window, + pool_bytes: 2 * window, + ..NixlConfig::default() + }) + .map_err(native_error)?; + let mut metadata = + HeaderValue::from_str(&STANDARD.encode(agent.local_metadata().map_err(native_error)?)) + .map_err(|_| Error::General("Invalid NIXL agent metadata".into()))?; + metadata.set_sensitive(true); + Ok(Arc::new(Self { + agent, + name: HeaderValue::from_str(&name).expect("ASCII agent ID"), + metadata, + _budget: budget, + })) + } + + pub(crate) async fn reserve(&self) -> Result { + self.agent + .reserve(Duration::from_secs(60)) + .await + .map_err(native_error) + } +} + +pub(crate) fn native_error(error: rustfs_nixl::NixlError) -> Error { + Error::General(format!("NIXL/UCX: {error}")) +} + +/// A cancelled or interrupted HTTPS exchange gives no proof that peer DMA has +/// finished. Such windows retain their registration and its budget until exit. +pub(crate) struct Exposed { + chunk: Option, + pool: Arc, +} + +impl Exposed { + pub(crate) fn new(chunk: StagingChunk, pool: Arc) -> Self { + Self { + chunk: Some(chunk), + pool, + } + } + + pub(crate) fn finished(mut self) -> StagingChunk { + self.chunk + .take() + .expect("exposed window is owned until completion") + } +} + +impl Drop for Exposed { + fn drop(&mut self) { + if let Some(chunk) = self.chunk.take() { + QUARANTINE + .lock() + .unwrap_or_else(|p| p.into_inner()) + .push((chunk, self.pool.clone())); + } + } +} diff --git a/nixl/src/transport.rs b/nixl/src/transport.rs new file mode 100644 index 00000000..490374c2 --- /dev/null +++ b/nixl/src/transport.rs @@ -0,0 +1,122 @@ +//! S3 object selection and native transport installation. + +mod download; +mod upload; + +use async_trait::async_trait; +use http::{HeaderMap, HeaderValue, Method, StatusCode}; +use rc_core::{DataTransferState, Error, ObjectInfo, RemotePath, Result}; +use rc_s3::data_transport::*; +use rustfs_nixl::{RDMA_REPLY_HEADER, StagingChunk}; +use std::sync::Arc; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; +use tokio::sync::OnceCell; + +use crate::pool::{Exposed, Pool, SMALL_WINDOW, WINDOW, native_error}; +use crate::wire; + +pub(crate) struct Factory; + +impl ObjectDataTransportFactory for Factory { + fn create(&self, context: DataTransportContext) -> Result> { + Ok(Arc::new(Transport { + control: context.control, + small_pool: OnceCell::new(), + full_pool: OnceCell::new(), + })) + } +} + +struct Transport { + control: Arc, + small_pool: OnceCell>, + full_pool: OnceCell>, +} + +fn failed(state: DataTransferState, source: Error) -> DataTransportError { + DataTransportError { + state, + message: "RustFS NIXL object transfer".into(), + source: Some(Box::new(source)), + } +} + +fn unavailable(source: Error) -> DataTransportError { + failed(DataTransferState::NotAccepted, source) +} +fn rejected(source: Error) -> DataTransportError { + failed(DataTransferState::ConfirmedFailure, source) +} +fn unknown(source: Error) -> DataTransportError { + failed(DataTransferState::OutcomeUnknown, source) +} + +impl Transport { + async fn exchange( + &self, + request: ControlRequest, + exposed: Exposed, + ) -> DataTransportResult<(ControlResponse, Exposed)> { + match self.control.execute_headers(request).await { + Ok(response) => Ok((response, exposed)), + Err(error @ Error::RequestRejected(_)) => { + // ControlExecutor rejected the request locally before sending it. + drop(exposed.finished()); + Err(unavailable(error)) + } + Err(error) => Err(unknown(error)), + } + } + + async fn pool(&self, required: u64) -> DataTransportResult<&Arc> { + if let Some(pool) = self.full_pool.get() { + return Ok(pool); + } + let (slot, window) = if required <= SMALL_WINDOW as u64 { + (&self.small_pool, SMALL_WINDOW) + } else { + (&self.full_pool, WINDOW) + }; + slot.get_or_try_init(|| async { + tokio::task::spawn_blocking(move || Pool::open(window)) + .await + .map_err(|_| Error::General("NIXL agent startup was interrupted".into()))? + }) + .await + .map_err(unavailable) + } +} + +#[async_trait] +impl ObjectDataTransport for Transport { + fn staged_upload(&self) -> Option<&dyn StagedUploadTransport> { + Some(self) + } + + async fn download_file( + &self, + request: DownloadRequest<'_>, + file: Arc, + ) -> DataTransportResult> { + self.download_into(request, download::Sink::File(file)) + .await + .map(Some) + } + + async fn download( + &self, + request: DownloadRequest<'_>, + target: &mut (dyn AsyncWrite + Send + Unpin), + ) -> DataTransportResult { + self.download_into(request, download::Sink::Writer(target)) + .await + } + + async fn upload( + &self, + request: UploadRequest<'_>, + source: &mut (dyn AsyncRead + Unpin + Send), + ) -> DataTransportResult { + self.upload_reader(request, source).await + } +} diff --git a/nixl/src/transport/download.rs b/nixl/src/transport/download.rs new file mode 100644 index 00000000..eedb2acc --- /dev/null +++ b/nixl/src/transport/download.rs @@ -0,0 +1,219 @@ +use super::*; + +pub(super) enum Sink<'a> { + File(Arc), + Writer(&'a mut (dyn AsyncWrite + Send + Unpin)), +} + +struct Selection<'a> { + path: &'a RemotePath, + query: Vec<(String, String)>, + total: u64, + etag: HeaderValue, +} + +impl Transport { + async fn fetch( + &self, + selection: &Selection<'_>, + offset: u64, + len: usize, + ranged: bool, + ) -> DataTransportResult { + let pool = self.pool(len as u64).await?; + let mut headers = HeaderMap::new(); + headers.insert("if-match", selection.etag.clone()); + let expected = if ranged { + let range = format!("bytes={offset}-{}", offset + len as u64 - 1); + headers.insert( + "range", + HeaderValue::from_str(&range).expect("numeric range"), + ); + StatusCode::PARTIAL_CONTENT + } else { + StatusCode::OK + }; + let chunk = pool.reserve().await.map_err(unavailable)?; + // A zero-byte object still needs a valid, nonempty NIXL descriptor. + wire::bind( + &mut headers, + &pool.name, + &pool.metadata, + chunk.addr(), + len.max(1), + ) + .map_err(unavailable)?; + let exposed = Exposed::new(chunk, pool.clone()); + let (response, exposed) = self + .exchange( + wire::request( + Method::GET, + selection.path, + selection.query.clone(), + headers, + ), + exposed, + ) + .await?; + if !response.status.is_success() { + return Err(rejected(wire::s3_error(response.status, selection.path))); + } + if !response.headers.contains_key(RDMA_REPLY_HEADER) { + // An ordinary successful GET returned the object in its HTTP body. + // It is safe to try the ordinary reader before publishing any bytes. + drop(exposed.finished()); + return Err(unavailable(Error::UnsupportedFeature( + "The endpoint served GET over HTTP".into(), + ))); + } + if response.status != expected { + return Err(rejected(Error::General( + "Unexpected NIXL GET status".into(), + ))); + } + wire::receipt(expected, &response.headers, len as u64).map_err(rejected)?; + let mut chunk = exposed.finished(); + if wire::field(&response.headers, "content-length") + .map_err(rejected)? + .is_some_and(|value| value != "0") + { + return Err(rejected(Error::General( + "NIXL GET returned an HTTP payload".into(), + ))); + } + if ranged { + let expected_range = format!( + "bytes {offset}-{}/{}", + offset + len as u64 - 1, + selection.total + ); + if wire::field(&response.headers, "content-range").map_err(rejected)? + != Some(&expected_range) + { + return Err(rejected(Error::General( + "NIXL GET returned a different object range".into(), + ))); + } + } + chunk.advance(len).map_err(native_error).map_err(rejected)?; + Ok(chunk) + } + + pub(super) async fn download_into( + &self, + request: DownloadRequest<'_>, + mut target: Sink<'_>, + ) -> DataTransportResult { + if request.options.customer_key.is_some() { + return Err(unavailable(Error::UnsupportedFeature( + "NIXL does not encrypt SSE-C payloads in transit".into(), + ))); + } + let mut query = Vec::new(); + if let Some(version) = &request.options.version_id { + query.push(("versionId".into(), version.clone())); + } + let mut headers = HeaderMap::new(); + if request.options.checksum_mode { + headers.insert("x-amz-checksum-mode", HeaderValue::from_static("ENABLED")); + } + let head = self + .control + .execute_headers(wire::request( + Method::HEAD, + request.path, + query.clone(), + headers, + )) + .await + .map_err(unavailable)?; + if head.status != StatusCode::OK { + return Err(rejected(wire::s3_error(head.status, request.path))); + } + let total = wire::field(&head.headers, "content-length") + .map_err(rejected)? + .and_then(|v| v.parse::().ok()) + .ok_or_else(|| rejected(Error::General("Missing or invalid object length".into())))?; + let length = request.max_bytes.unwrap_or(total).min(total); + if length > request.max_receive_bytes { + return Err(rejected(Error::General( + "NIXL object exceeds the receive bound".into(), + ))); + } + if query.is_empty() + && let Some(version) = + wire::field(&head.headers, "x-amz-version-id").map_err(rejected)? + { + query.push(("versionId".into(), version.into())); + } + let etag = head + .headers + .get("etag") + .cloned() + .ok_or_else(|| rejected(Error::General("Object HEAD has no ETag".into())))?; + let selection = Selection { + path: request.path, + query, + total, + etag, + }; + let ranged = length > 0 && (request.max_bytes.is_some() || length > WINDOW as u64); + let first = length.min(WINDOW as u64) as usize; + let mut current = self.fetch(&selection, 0, first, ranged).await?; + let mut end = first as u64; + let mut checksum = PayloadChecksumVerifier::new(&head.headers).map_err(rejected)?; + loop { + let write = async { + if length == total { + checksum.update(current.staged().map_err(native_error)?); + } + let offset = end - current.len() as u64; + match &mut target { + Sink::Writer(writer) => { + writer + .write_all(current.staged().map_err(native_error)?) + .await? + } + Sink::File(file) => { + use std::os::unix::fs::FileExt; + let file = file.clone(); + tokio::task::spawn_blocking(move || { + file.write_all_at(current.staged().map_err(native_error)?, offset)?; + Ok::<_, Error>(()) + }) + .await + .map_err(|_| Error::General("NIXL file write was interrupted".into()))??; + } + } + (request.on_progress)(end, Some(length)); + Ok::<_, Error>(()) + }; + if end == length { + write.await.map_err(rejected)?; + break; + } + let size = (length - end).min(WINDOW as u64) as usize; + let (written, next) = tokio::join!(write, self.fetch(&selection, end, size, true)); + written.map_err(rejected)?; + current = next.map_err(|mut err| { + err.state = DataTransferState::ConfirmedFailure; + err + })?; + end += size as u64; + } + if length == total { + checksum.verify(&head.headers).map_err(rejected)?; + } + if let Sink::Writer(writer) = target { + writer + .flush() + .await + .map_err(Error::from) + .map_err(rejected)?; + } + Ok(DownloadResult { + bytes_transferred: length, + content_length: length, + }) + } +} diff --git a/nixl/src/transport/upload.rs b/nixl/src/transport/upload.rs new file mode 100644 index 00000000..707e60c9 --- /dev/null +++ b/nixl/src/transport/upload.rs @@ -0,0 +1,162 @@ +use super::*; + +impl Transport { + pub(super) async fn upload_reader( + &self, + request: UploadRequest<'_>, + source: &mut (dyn AsyncRead + Unpin + Send), + ) -> DataTransportResult { + let len = part_len(&request)?; + let pool = self.pool(request.content_length).await?; + let mut chunk = pool.reserve().await.map_err(unavailable)?; + let dest = chunk + .spare_mut() + .map_err(native_error) + .map_err(unavailable)?; + source + .read_exact(&mut dest[..len]) + .await + .map_err(Error::from) + .map_err(rejected)?; + if source + .read(&mut [0_u8; 1]) + .await + .map_err(Error::from) + .map_err(rejected)? + != 0 + { + return Err(rejected(Error::Conflict( + "NIXL part source exceeds its declared length".into(), + ))); + } + self.send_part(&request, pool, chunk) + .await? + .ok_or_else(declined_part) + } +} + +fn declined_part() -> DataTransportError { + rejected(Error::UnsupportedFeature( + "The endpoint did not accept the NIXL part".into(), + )) +} + +fn part_len(request: &UploadRequest<'_>) -> DataTransportResult { + usize::try_from(request.content_length) + .ok() + .filter(|n| (1..=WINDOW).contains(n)) + .ok_or_else(|| { + unavailable(Error::UnsupportedFeature( + "Part exceeds the registered NIXL window".into(), + )) + }) +} + +#[async_trait] +impl StagedUploadTransport for Transport { + fn max_part_size(&self) -> u64 { + WINDOW as u64 + } + + async fn probe( + &self, + path: &RemotePath, + upload_id: &str, + first_part_bytes: u64, + ) -> DataTransportResult { + let pool = self.pool(first_part_bytes).await?; + let mut chunk = pool.reserve().await.map_err(unavailable)?; + chunk + .append(&[0]) + .map_err(native_error) + .map_err(unavailable)?; + let options = rc_core::ObjectWriteOptions::default(); + let request = UploadRequest { + path, + options: &options, + content_length: 1, + operation: UploadOperation::UploadPart { + upload_id, + part_number: 1, + }, + checksum_sha256: None, + }; + Ok(self.send_part(&request, pool, chunk).await?.is_some()) + } + + async fn upload_file_part( + &self, + request: UploadRequest<'_>, + file: Arc, + offset: u64, + ) -> DataTransportResult { + use std::os::unix::fs::FileExt; + let len = part_len(&request)?; + let pool = self.pool(request.content_length).await?; + let mut chunk = pool.reserve().await.map_err(unavailable)?; + let chunk = tokio::task::spawn_blocking(move || { + file.read_exact_at(&mut chunk.spare_mut().map_err(native_error)?[..len], offset)?; + Ok::<_, Error>(chunk) + }) + .await + .map_err(|_| rejected(Error::General("NIXL file read was interrupted".into())))? + .map_err(rejected)?; + self.send_part(&request, pool, chunk) + .await? + .ok_or_else(declined_part) + } +} + +impl Transport { + async fn send_part( + &self, + request: &UploadRequest<'_>, + pool: &Arc, + chunk: StagingChunk, + ) -> DataTransportResult> { + let UploadOperation::UploadPart { + upload_id, + part_number, + } = request.operation + else { + return Err(unavailable(Error::UnsupportedFeature( + "NIXL writes require an unpublished multipart part".into(), + ))); + }; + let len = part_len(request)?; + let mut headers = HeaderMap::new(); + wire::bind(&mut headers, &pool.name, &pool.metadata, chunk.addr(), len) + .map_err(unavailable)?; + let query = vec![ + ("uploadId".into(), upload_id.into()), + ("partNumber".into(), part_number.to_string()), + ]; + let exposed = Exposed::new(chunk, pool.clone()); + let (response, exposed) = self + .exchange( + wire::request(Method::PUT, request.path, query, headers), + exposed, + ) + .await?; + if response.status != StatusCode::OK { + // RustFS can start reading ahead before it validates the multipart ID. + return Err(rejected(wire::s3_error(response.status, request.path))); + } + if !response.headers.contains_key(RDMA_REPLY_HEADER) { + drop(exposed.finished()); + return Ok(None); + } + wire::receipt(StatusCode::OK, &response.headers, len as u64).map_err(unknown)?; + drop(exposed.finished()); + let etag = wire::field(&response.headers, "etag") + .map_err(rejected)? + .filter(|e| !e.is_empty()) + .ok_or_else(|| rejected(Error::General("NIXL UploadPart returned no ETag".into())))?; + let mut object = ObjectInfo::file(&request.path.key, len as i64); + object.etag = Some(etag.into()); + Ok(Some(UploadResult { + object, + checksum_sha256: None, + })) + } +} diff --git a/nixl/src/wire.rs b/nixl/src/wire.rs new file mode 100644 index 00000000..fb36b5c7 --- /dev/null +++ b/nixl/src/wire.rs @@ -0,0 +1,116 @@ +//! RustFS S3-over-NIXL request and response fields. + +use http::{HeaderMap, HeaderValue, Method, StatusCode}; +use rc_core::{Error, RemotePath, Result}; +use rc_s3::data_transport::{ControlPayload, ControlRequest}; +use rustfs_nixl::{ + NIXL_AGENT_HEADER, NIXL_BUFFER_HEADER, NIXL_METADATA_HEADER, RDMA_BYTES_TRANSFERRED_HEADER, + RDMA_REPLY_HEADER, +}; +use std::time::{Duration, Instant}; + +pub(crate) fn request( + method: Method, + path: &RemotePath, + query: Vec<(String, String)>, + headers: HeaderMap, +) -> ControlRequest { + ControlRequest { + method, + path: path.clone(), + query, + headers, + body: Default::default(), + payload: ControlPayload::External { + deadline: Instant::now() + Duration::from_secs(3600), + }, + response_limit: 64 * 1024, + } +} + +pub(crate) fn bind( + headers: &mut HeaderMap, + agent: &HeaderValue, + metadata: &HeaderValue, + address: usize, + len: usize, +) -> Result<()> { + let mut buffer = HeaderValue::from_str(&format!("dram:0:{address}:{len}")) + .map_err(|_| Error::General("Invalid NIXL buffer description".into()))?; + buffer.set_sensitive(true); + headers.insert(NIXL_AGENT_HEADER, agent.clone()); + headers.insert(NIXL_METADATA_HEADER, metadata.clone()); + headers.insert(NIXL_BUFFER_HEADER, buffer); + Ok(()) +} + +pub(crate) fn field<'a>(headers: &'a HeaderMap, name: &str) -> Result> { + let mut values = headers.get_all(name).iter(); + let first = values + .next() + .map(|v| v.to_str()) + .transpose() + .map_err(|_| Error::General(format!("Invalid {name} response header")))?; + if values.next().is_some() { + return Err(Error::General(format!("Duplicate {name} response header"))); + } + Ok(first) +} + +pub(crate) fn receipt(status: StatusCode, headers: &HeaderMap, bytes: u64) -> Result<()> { + if field(headers, RDMA_REPLY_HEADER)? != Some(status.as_str()) { + return Err(Error::UnsupportedFeature( + "The endpoint did not confirm a RustFS NIXL transfer".into(), + )); + } + let moved = field(headers, RDMA_BYTES_TRANSFERRED_HEADER)? + .unwrap_or("0") + .parse::() + .map_err(|_| Error::General("Invalid NIXL transfer count".into()))?; + if moved != bytes { + return Err(Error::General(format!( + "NIXL transferred {moved} of {bytes} bytes" + ))); + } + Ok(()) +} + +pub(crate) fn s3_error(status: StatusCode, path: &RemotePath) -> Error { + match status { + StatusCode::NOT_FOUND => Error::NotFound(path.to_string()), + StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED => { + Error::Auth(format!("S3 refused access to {path}")) + } + StatusCode::PRECONDITION_FAILED | StatusCode::CONFLICT => { + Error::Conflict(format!("Object changed: {path}")) + } + _ => Error::General(format!("S3 returned HTTP {status} for {path}")), + } +} + +#[cfg(test)] +mod tests { + use super::*; + use http::{HeaderMap, StatusCode}; + + #[test] + fn empty_http_body_has_a_separate_logical_byte_count() { + let mut headers = HeaderMap::new(); + headers.insert("content-length", "0".parse().unwrap()); + headers.insert("x-amz-rdma-reply", "206".parse().unwrap()); + headers.insert("x-amz-rdma-bytes-transferred", "4".parse().unwrap()); + assert!(receipt(StatusCode::PARTIAL_CONTENT, &headers, 4).is_ok()); + assert!(receipt(StatusCode::OK, &headers, 4).is_err()); + assert!(receipt(StatusCode::PARTIAL_CONTENT, &headers, 5).is_err()); + headers.append("x-amz-rdma-bytes-transferred", "4".parse().unwrap()); + assert!(receipt(StatusCode::PARTIAL_CONTENT, &headers, 4).is_err()); + } + + #[test] + fn ordinary_s3_success_is_not_a_transfer_receipt() { + assert!(receipt(StatusCode::OK, &HeaderMap::new(), 0).is_err()); + } +} + +#[cfg(test)] +mod native_test; diff --git a/nixl/src/wire/native_test.rs b/nixl/src/wire/native_test.rs new file mode 100644 index 00000000..1faa4f8c --- /dev/null +++ b/nixl/src/wire/native_test.rs @@ -0,0 +1,47 @@ +use super::*; +use crate::pool::Pool; +use rustfs_nixl::{NixlConfig, NixlServer, RdmaToken}; + +#[tokio::test] +async fn rustfs_reads_and_writes_the_advertised_host_window() { + let client = Pool::open(4096).unwrap(); + let peer = NixlServer::new(&NixlConfig { + agent_name: "rc-interop-peer".into(), + chunk_bytes: 4096, + pool_bytes: 4096, + ..Default::default() + }) + .unwrap(); + let mut source = client.reserve().await.unwrap(); + source.append(b"upload").unwrap(); + let mut fields = HeaderMap::new(); + bind( + &mut fields, + &client.name, + &client.metadata, + source.addr(), + 6, + ) + .unwrap(); + let token = RdmaToken::from_headers( + fields[NIXL_AGENT_HEADER].to_str().unwrap(), + Some(fields[NIXL_METADATA_HEADER].to_str().unwrap()), + fields[NIXL_BUFFER_HEADER].to_str().unwrap(), + ) + .unwrap(); + + let staging = peer.try_reserve().unwrap(); + let mut staging = peer + .read_from_client_owned("input", &token, 0, 6, staging) + .await + .unwrap(); + assert_eq!(staging.staged().unwrap(), b"upload"); + staging.clear(); + staging.append(b"result").unwrap(); + let (written, _) = peer + .write_to_client_owned("output", &token, 0, staging) + .await + .unwrap(); + assert_eq!(written, 6); + assert_eq!(source.staged().unwrap(), b"result"); +} diff --git a/nixl/tests/interop.sh b/nixl/tests/interop.sh new file mode 100755 index 00000000..c67767aa --- /dev/null +++ b/nixl/tests/interop.sh @@ -0,0 +1,48 @@ +#!/usr/bin/env bash +# Run against disposable buckets on two verified HTTPS aliases. The second +# endpoint runs the same RustFS binary with RUSTFS_NIXL_ENABLE=false. +set -euo pipefail +: "${RC:?path to the native rc executable}" +: "${NIXL_BUCKET:?alias/bucket on the native endpoint}" +: "${HTTP_BUCKET:?alias/bucket on the HTTP-only endpoint}" +tmp=$(mktemp -d) +trap 'rm -rf "$tmp"' EXIT +prefix="rc-interop-$(basename "$tmp")" +nr() { "$RC" --data-transport rdma "$@"; } +plain() { "$RC" --data-transport http "$@"; } +automatic() { "$RC" --data-transport auto "$@"; } + +# Cross both upload-part and download-window boundaries with distinct data. +dd if=/dev/urandom of="$tmp/model" bs=1M count=129 status=none +printf 'NIXL part receipt\n' > "$tmp/small" +: > "$tmp/empty" +for name in model small empty; do + object="$NIXL_BUCKET/$prefix/$name" + nr cp "$tmp/$name" "$object" + nr cp "$object" "$tmp/native-$name" + plain cp "$object" "$tmp/http-$name" + cmp "$tmp/$name" "$tmp/native-$name" + cmp "$tmp/$name" "$tmp/http-$name" +done +nr object head --bytes 19 "$NIXL_BUCKET/$prefix/model" > "$tmp/range" +head -c 19 "$tmp/model" | cmp - "$tmp/range" + +plain cp "$tmp/small" "$NIXL_BUCKET/$prefix/http-source" +nr cp "$NIXL_BUCKET/$prefix/http-source" "$tmp/from-http" +cmp "$tmp/small" "$tmp/from-http" + +automatic cp "$tmp/small" "$NIXL_BUCKET/$prefix/auto" +nr cp "$NIXL_BUCKET/$prefix/auto" "$tmp/auto" +cmp "$tmp/small" "$tmp/auto" + +object="$HTTP_BUCKET/$prefix/declined" +plain cp "$tmp/small" "$object" +if nr cp --overwrite=true "$tmp/model" "$object"; then + echo "Expected native upload to be declined" >&2 + exit 1 +fi +plain cp "$object" "$tmp/preserved" +cmp "$tmp/small" "$tmp/preserved" +automatic cp --overwrite=true "$tmp/model" "$object" +automatic cp "$object" "$tmp/fallback" +cmp "$tmp/model" "$tmp/fallback" From 3fef34da903c9ba147a0b05dc1846fffae8986a4 Mon Sep 17 00:00:00 2001 From: GatewayJ <835269233@qq.com> Date: Fri, 20 Nov 2026 19:31:59 +0800 Subject: [PATCH 2/5] refactor(phase-3): remove the private RDMA gateway integration --- .gitignore | 4 - .gitmodules | 4 - Cargo.toml | 2 +- crates/cli/src/launcher.rs | 89 ++--------- crates/cli/src/lib.rs | 2 +- crates/s3/src/client.rs | 200 +++++-------------------- crates/s3/src/data_transport.rs | 36 +---- docs/ADR/0001-object-data-transport.md | 40 ++--- docs/rdma-build.md | 77 +--------- nixl/src/transport.rs | 4 +- nixl/src/wire.rs | 8 +- rdma/Cargo.toml | 37 ----- scripts/build-rdma.sh | 22 +-- scripts/tests/test_build_rdma.py | 106 ++++--------- vendor/rustfs-ucx | 1 - 15 files changed, 118 insertions(+), 514 deletions(-) delete mode 100644 .gitmodules delete mode 100644 rdma/Cargo.toml delete mode 160000 vendor/rustfs-ucx diff --git a/.gitignore b/.gitignore index 1e045b65..a0b6ddef 100644 --- a/.gitignore +++ b/.gitignore @@ -28,8 +28,4 @@ coverage/ # Cargo.lock CLAUDE.md -# The independent opt-in build owns its artifacts and lockfile. -/rdma/target/ -/rdma/Cargo.lock - /nixl/target/ diff --git a/.gitmodules b/.gitmodules deleted file mode 100644 index 47b6db4a..00000000 --- a/.gitmodules +++ /dev/null @@ -1,4 +0,0 @@ -[submodule "vendor/rustfs-ucx"] - path = vendor/rustfs-ucx - url = git@github.com:rustfs/rustfs-ucx.git - branch = s3-rdma diff --git a/Cargo.toml b/Cargo.toml index 2dbf5fea..af94344a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -exclude = ["nixl", "rdma", "vendor/rustfs-ucx"] +exclude = ["nixl"] resolver = "3" members = ["crates/cli", "crates/core", "crates/s3"] diff --git a/crates/cli/src/launcher.rs b/crates/cli/src/launcher.rs index 178b2878..35c0da03 100644 --- a/crates/cli/src/launcher.rs +++ b/crates/cli/src/launcher.rs @@ -45,16 +45,6 @@ fn allow_log_metadata(metadata: &tracing::Metadata<'_>) -> bool { /// Run the shared CLI launcher, preserving its worker-thread and exit behavior. pub fn run() { - run_with_shutdown(|| async {}); -} - -/// Runs host cleanup after the command while its async runtime is still available. -/// The host bounds its own cleanup and reports retained resources as appropriate. -pub fn run_with_shutdown(shutdown: S) -where - S: FnOnce() -> F + Send + 'static, - F: Future + 'static, -{ let cli = Cli::parse(); let env_is_set = std::env::var_os(EnvFilter::DEFAULT_ENV).is_some(); let env_filter = build_env_filter(cli.debug, env_is_set); @@ -66,43 +56,18 @@ where .with(env_filter) .init(); - let exit_code = match run_command(cli, shutdown) { - Ok(exit_code) => exit_code, - Err(error) => { - eprintln!("{error}"); - ExitCode::GeneralError - } - }; + let exit_code = + match run_async_command(move || Box::pin(commands::execute(cli)), command_runtime) { + Ok(exit_code) => exit_code, + Err(error) => { + eprintln!("{error}"); + ExitCode::GeneralError + } + }; std::process::exit(exit_code.as_i32()); } -fn run_command(cli: Cli, shutdown: S) -> Result -where - S: FnOnce() -> F + Send + 'static, - F: Future + 'static, -{ - run_async_command( - move || finish_with_shutdown(commands::execute(cli), shutdown), - command_runtime, - ) -} - -fn finish_with_shutdown(command: C, shutdown: S) -> impl Future -where - C: Future, - S: FnOnce() -> F, - F: Future, -{ - // Keep the cleanup future small even when an SDK command has a large state. - let command = Box::pin(command); - async move { - let output = command.await; - shutdown().await; - output - } -} - fn command_runtime() -> std::io::Result { tokio::runtime::Builder::new_multi_thread() .thread_stack_size(COMMAND_THREAD_STACK_SIZE) @@ -205,37 +170,6 @@ mod tests { assert_eq!(exit_code, ExitCode::UnsupportedFeature); } - #[test] - fn host_cleanup_runs_after_a_failed_command_before_runtime_shutdown() { - let state = Arc::new(std::sync::atomic::AtomicUsize::new(0)); - let observed = Arc::clone(&state); - let exit_code = run_async_command( - move || { - let shutdown_state = Arc::clone(&state); - finish_with_shutdown( - async move { - state.store(1, Ordering::Release); - ExitCode::GeneralError - }, - move || async move { - assert_eq!(shutdown_state.load(Ordering::Acquire), 1); - assert_eq!(std::thread::current().name(), Some(COMMAND_THREAD_NAME)); - tokio::spawn(async move { - tokio::task::yield_now().await; - shutdown_state.store(2, Ordering::Release); - }) - .await - .expect("cleanup task completes in the command runtime"); - }, - ) - }, - test_runtime, - ) - .expect("host cleanup completes"); - assert_eq!(exit_code, ExitCode::GeneralError); - assert_eq!(observed.load(Ordering::Acquire), 2); - } - #[test] fn command_launcher_uses_the_named_worker_thread() { let thread_name = run_async_command( @@ -260,11 +194,8 @@ mod tests { usize::from(payload[0]) + usize::from(payload[LARGE_FUTURE_SIZE - 1]) } - let result = run_async_command( - || finish_with_shutdown(large_future(), || async {}), - test_runtime, - ) - .expect("large command future should complete on the sized worker stack"); + let result = run_async_command(|| Box::pin(large_future()), test_runtime) + .expect("large command future should complete on the sized worker stack"); assert_eq!(result, 14); } diff --git a/crates/cli/src/lib.rs b/crates/cli/src/lib.rs index 9902e51a..21540f2d 100644 --- a/crates/cli/src/lib.rs +++ b/crates/cli/src/lib.rs @@ -6,7 +6,7 @@ pub mod commands; pub(crate) mod confirm; pub mod exit_code; mod launcher; -pub use launcher::{run, run_with_shutdown}; +pub use launcher::run; pub mod output; pub(crate) mod private_file; pub(crate) mod secret_input; diff --git a/crates/s3/src/client.rs b/crates/s3/src/client.rs index ddd3d911..1d8d2fb5 100644 --- a/crates/s3/src/client.rs +++ b/crates/s3/src/client.rs @@ -65,9 +65,8 @@ use std::sync::Arc; use std::time::Duration; use crate::data_transport::{ - self, ControlExecutor, ControlPayload, ControlRequest, ControlResponse, DataTransportContext, - DownloadRequest, ObjectDataTransport, ObservedReader, ObservedWriter, UploadOperation, - UploadRequest, UploadResult, WriteCondition, + self, ControlExecutor, ControlRequest, ControlResponse, DownloadRequest, ObjectDataTransport, + ObservedReader, ObservedWriter, UploadOperation, UploadRequest, UploadResult, WriteCondition, }; use tokio::io::AsyncWrite; use tokio::io::AsyncWriteExt; @@ -1926,10 +1925,7 @@ impl S3Client { if client.data_transport_mode != rc_core::DataTransportMode::Http && let Some(factory) = data_transport::installed_factory() { - client.data_transport = Some(factory.create(DataTransportContext { - endpoint: client.alias.endpoint.clone(), - control: Arc::new(client.clone()), - })?); + client.data_transport = Some(factory.create(Arc::new(client.clone()))?); } Ok(client) } @@ -3911,8 +3907,7 @@ impl S3Client { method: &Method, url: &str, headers: &HeaderMap, - body: &[u8], - payload: ControlPayload, + body: SignableBody<'_>, time: std::time::SystemTime, ) -> Result { let mut settings = SigningSettings::default(); @@ -3923,10 +3918,7 @@ impl S3Client { method, url, headers, - match payload { - ControlPayload::Body => SignableBody::Bytes(body), - ControlPayload::External { .. } => SignableBody::UnsignedPayload, - }, + body, RequestSigningOptions { region: &self.alias.region, settings, @@ -7847,51 +7839,24 @@ impl ObjectStore for S3Client { /// External control exchanges retain the host client's TLS and signing policy. #[async_trait] impl ControlExecutor for S3Client { - async fn execute(&self, request: ControlRequest) -> Result { - self.execute_control(request, true).await - } - async fn execute_headers(&self, request: ControlRequest) -> Result { - self.execute_control(request, false).await - } -} - -impl S3Client { - async fn execute_control( - &self, - request: ControlRequest, - read_body: bool, - ) -> Result { if self.alias.anonymous { return Err(Error::RequestRejected( "External object control requires an authenticated S3 principal".to_string(), )); } - const MAX_CONTROL_BYTES: usize = 1024 * 1024; - if request.body.len() > MAX_CONTROL_BYTES - || request.response_limit == 0 - || request.response_limit > MAX_CONTROL_BYTES - { - return Err(Error::RequestRejected( - "Control envelope exceeds the bounded exchange policy".to_string(), - )); - } - if matches!(request.payload, ControlPayload::External { .. }) && !request.body.is_empty() { - return Err(Error::RequestRejected( - "An external payload control request must have an empty HTTPS body".to_string(), - )); - } - let operation_deadline = match request.payload { - ControlPayload::Body => None, - ControlPayload::External { deadline } => { - if deadline <= std::time::Instant::now() { - return Err(Error::RequestRejected( + let remaining = || { + request + .deadline + .checked_duration_since(std::time::Instant::now()) + .filter(|duration| !duration.is_zero()) + .ok_or_else(|| { + Error::RequestRejected( "The external control operation deadline has elapsed".to_string(), - )); - } - Some(deadline) - } + ) + }) }; + remaining()?; let url = self.external_control_url(&request.path, &request.query)?; let mut headers = request.headers; for name in [ @@ -7929,11 +7894,7 @@ impl S3Client { ); headers.insert( "x-amz-content-sha256", - HeaderValue::from_str(&match request.payload { - ControlPayload::Body => Self::sha256_hash(&request.body), - ControlPayload::External { .. } => "UNSIGNED-PAYLOAD".to_string(), - }) - .map_err(|_| Error::RequestRejected("Invalid payload digest".to_string()))?, + HeaderValue::from_static("UNSIGNED-PAYLOAD"), ); if headers.values().any(|value| value.to_str().is_err()) { return Err(Error::RequestRejected( @@ -7945,82 +7906,34 @@ impl S3Client { &request.method, url.as_str(), &headers, - &request.body, - request.payload, + SignableBody::UnsignedPayload, std::time::SystemTime::now(), ) .await?; - let client = if operation_deadline.is_some() { - self.external_http_client - .get_or_try_init(|| async { - build_reqwest_client_with_read_policy( - self.alias.insecure, - self.alias.ca_bundle.as_deref(), - self.alias.client_cert.as_deref(), - self.alias.client_key.as_deref(), - self.alias.timeout.as_ref(), - false, - ) - .await - }) - .await? - } else { - &self.xml_http_client - }; - let mut outgoing = client + let client = self + .external_http_client + .get_or_try_init(|| async { + build_reqwest_client_with_read_policy( + self.alias.insecure, + self.alias.ca_bundle.as_deref(), + self.alias.client_cert.as_deref(), + self.alias.client_key.as_deref(), + self.alias.timeout.as_ref(), + false, + ) + .await + }) + .await?; + let mut response = client .request(request.method, url) .headers(signed) - .body(request.body); - if let Some(deadline) = operation_deadline { - let remaining = deadline - .checked_duration_since(std::time::Instant::now()) - .filter(|remaining| !remaining.is_zero()) - .ok_or_else(|| { - Error::RequestRejected( - "The external control operation deadline has elapsed".to_string(), - ) - })?; - outgoing = outgoing.timeout(remaining); - } - let response = outgoing + .timeout(remaining()?) .send() .await .map_err(|_| Error::Network("External control exchange failed".to_string()))?; - let status = response.status(); - let headers = response.headers().clone(); - if !read_body { - return Ok(ControlResponse { - status, - headers, - body: Bytes::new(), - }); - } - if response - .content_length() - .is_some_and(|length| length > request.response_limit as u64) - { - return Err(Error::Network( - "External control response exceeds its bound".to_string(), - )); - } - let mut body = Vec::new(); - let mut stream = response.bytes_stream(); - while let Some(chunk) = stream - .try_next() - .await - .map_err(|_| Error::Network("External control response was interrupted".to_string()))? - { - if chunk.len() > request.response_limit.saturating_sub(body.len()) { - return Err(Error::Network( - "External control response exceeds its bound".to_string(), - )); - } - body.extend_from_slice(&chunk); - } Ok(ControlResponse { - status, - headers, - body: Bytes::from(body), + status: response.status(), + headers: std::mem::take(response.headers_mut()), }) } } @@ -15654,8 +15567,7 @@ mod tests { &Method::GET, sdk_request.uri(), &headers, - &[], - ControlPayload::Body, + SignableBody::Bytes(&[]), time, ) .await @@ -15684,33 +15596,10 @@ mod tests { path: RemotePath::new("test", "bucket", "key"), query: Vec::new(), headers: HeaderMap::new(), - body: Bytes::new(), - payload: ControlPayload::Body, - response_limit: 1024, + deadline: Instant::now() + Duration::from_secs(30), }; assert!(matches!( - ControlExecutor::execute(&client, request).await, - Err(Error::RequestRejected(_)) - )); - assert_eq!(replay.actual_requests().count(), 0); - } - - #[tokio::test] - async fn external_control_rejects_a_body_with_separately_delivered_payload() { - let (client, replay) = test_s3_client_with_response_sequence(Vec::new()); - let request = ControlRequest { - method: Method::PUT, - path: RemotePath::new("test", "bucket", "key"), - query: Vec::new(), - headers: HeaderMap::new(), - body: Bytes::from_static(b"unexpected control body"), - payload: ControlPayload::External { - deadline: Instant::now() + Duration::from_secs(30), - }, - response_limit: 1024, - }; - assert!(matches!( - ControlExecutor::execute(&client, request).await, + ControlExecutor::execute_headers(&client, request).await, Err(Error::RequestRejected(_)) )); assert_eq!(replay.actual_requests().count(), 0); @@ -15724,14 +15613,10 @@ mod tests { path: RemotePath::new("test", "bucket", "key"), query: Vec::new(), headers: HeaderMap::new(), - body: Bytes::new(), - payload: ControlPayload::External { - deadline: Instant::now(), - }, - response_limit: 1024, + deadline: Instant::now(), }; assert!(matches!( - ControlExecutor::execute(&client, request).await, + ControlExecutor::execute_headers(&client, request).await, Err(Error::RequestRejected(_)) )); assert_eq!(replay.actual_requests().count(), 0); @@ -15752,10 +15637,7 @@ mod tests { &Method::PUT, "https://objects.example.test/bucket/key", &headers, - &[], - ControlPayload::External { - deadline: Instant::now() + Duration::from_secs(30), - }, + SignableBody::UnsignedPayload, std::time::UNIX_EPOCH + Duration::from_secs(1_700_000_000), ) .await diff --git a/crates/s3/src/data_transport.rs b/crates/s3/src/data_transport.rs index 9810493e..b187f74e 100644 --- a/crates/s3/src/data_transport.rs +++ b/crates/s3/src/data_transport.rs @@ -10,7 +10,6 @@ use std::{ }; use async_trait::async_trait; -use bytes::Bytes; use http::{HeaderMap, Method, StatusCode}; use rc_core::{ DataTransferState, Error, ObjectInfo, ObjectWriteOptions, RemotePath, Result, @@ -26,51 +25,26 @@ pub struct ControlRequest { pub path: RemotePath, pub query: Vec<(String, String)>, pub headers: HeaderMap, - pub body: Bytes, - pub payload: ControlPayload, - pub response_limit: usize, -} - -/// Signing policy for a bounded control body or separately delivered payload. -#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] -pub enum ControlPayload { - /// Sign the exact HTTPS control body with SHA256. - #[default] - Body, - /// Use S3 UNSIGNED-PAYLOAD for a logical payload delivered by the provider. - /// The HTTPS request body must be empty; logical integrity is verified by - /// the provider and the authenticated S3 operation before publication. - External { deadline: std::time::Instant }, + pub deadline: std::time::Instant, } /// Uninterpreted control response; duplicate and binary headers are preserved. pub struct ControlResponse { pub status: StatusCode, pub headers: HeaderMap, - pub body: Bytes, } /// Host-owned HTTPS, credentials, signing, custom headers, and TLS configuration. #[async_trait] pub trait ControlExecutor: Send + Sync { - async fn execute(&self, request: ControlRequest) -> Result; - - /// Return only the status and headers. A server may decline an external GET - /// by streaming an ordinary S3 payload of arbitrary size. - async fn execute_headers(&self, request: ControlRequest) -> Result { - self.execute(request).await - } -} - -/// Configuration passed to a process-installed provider factory. -pub struct DataTransportContext { - pub endpoint: String, - pub control: Arc, + /// Read only the status and headers. A declined external GET can return an + /// ordinary S3 payload of arbitrary size. + async fn execute_headers(&self, request: ControlRequest) -> Result; } /// External transport construction is separate from process-wide policy. pub trait ObjectDataTransportFactory: Send + Sync { - fn create(&self, context: DataTransportContext) -> Result>; + fn create(&self, control: Arc) -> Result>; } static FACTORY: OnceLock> = OnceLock::new(); diff --git a/docs/ADR/0001-object-data-transport.md b/docs/ADR/0001-object-data-transport.md index 3f2f51f5..f48b8b05 100644 --- a/docs/ADR/0001-object-data-transport.md +++ b/docs/ADR/0001-object-data-transport.md @@ -7,16 +7,18 @@ completion, and abort continue to use the established S3 implementation. `rc-core` owns transport selection and business outcome classification. `rc-s3::data_transport` owns the optional provider ports, expressed with existing -S3 read/write options and borrowed asynchronous IO. A separately built executable -can install an `ObjectDataTransportFactory` before calling `rustfs_cli::run()`. +S3 read/write options, registered file transfers, and borrowed asynchronous IO. +The Linux NIXL executable installs an `ObjectDataTransportFactory` before +calling `rustfs_cli::run()`. The common launcher preserves command dispatch, output, exit codes, and the existing worker-thread configuration. -The provider receives a host-owned `ControlExecutor` for bounded, signed HTTPS -exchanges. Credentials, endpoint addressing, custom headers, and TLS remain in -the S3 client. The executor sends each exchange once and preserves response -status and duplicate headers. The provider owns acceptance proof and any -reconciliation required after an ambiguous response. +The provider supplies NIXL agent metadata and a registered buffer description +to a host-owned `ControlExecutor`. The S3 client signs and sends a bodyless +HTTPS request with a deadline. It returns the status and headers directly, +including duplicate headers. The provider verifies the RustFS transfer receipt +and byte count. Credentials, endpoint addressing, custom headers, and TLS +remain in the S3 client. External control requires an authenticated principal and verified HTTPS. Object paths and query values use the S3 encoding rules, with canonical path @@ -24,9 +26,11 @@ normalization disabled and single URI encoding during SigV4 signing. The encoding and signature are checked against actual AWS SDK requests for reserved characters, Unicode, repeated slashes, and selected version IDs. -Object reads to vectors, writers, and temporary files use the same provider -entry point. Files retain atomic replacement only after verified data and writer -flush. Existing version, checksum, encryption, and Range options are forwarded. +Object reads to vectors and writers share the streaming provider entry point. +For file downloads the provider can write registered memory directly to a +temporary file. The client verifies the transfer before replacing the +destination. Existing version, checksum, encryption, and Range options are +forwarded. Object writes and multipart parts retain their existing option validation and checksum verification; conditional file writes retain HTTP-managed multipart completion. No existing S3 options may be silently omitted by a provider. @@ -38,13 +42,11 @@ outcome state through redaction and multipart cleanup; generic timeout-string retry logic does not retry them. `rdma` reports an explicit failure when no provider or usable capability exists. -After a successful external PUT, a failed persisted-checksum HEAD cannot cause -the object write to replay. Multipart transfers record whether an external part -succeeded. Uncertain completion responses retain an unknown outcome and upload -identity; post-completion verification failures retain a confirmed failure with -their original diagnostic cause. These failures remain outside generic business -retry logic. +Nonempty native uploads use unpublished multipart parts. The client publishes +the object after all part receipts and ETags have been verified. An uncertain +completion retains the upload ID and an unknown outcome. A failed checksum +verification after completion cannot replay the write. Empty objects use S3 +directly. -Native provider code is outside the default workspace dependency graph. The -independent opt-in build and private dependency instructions are described in -the project build documentation. +The [RDMA build guide](../rdma-build.md) describes the Linux executable, +native dependencies, and runtime setup. diff --git a/docs/rdma-build.md b/docs/rdma-build.md index 9b9cb4a0..06677102 100644 --- a/docs/rdma-build.md +++ b/docs/rdma-build.md @@ -11,12 +11,16 @@ when needed. The native package pins the same `rustfs-nixl` and `nixl-sys` sources as the server. ```sh -cargo build --manifest-path nixl/Cargo.toml --release --locked +./scripts/build-rdma.sh --release export PATH="$PWD/nixl/target/release:$PATH" rc --data-transport rdma cp model.bin local/models/model.bin rc --data-transport rdma cp local/models/model.bin downloaded.bin ``` +The executable is `nixl/target/release/rc` with Cargo's default target directory. +The build script forwards Cargo options. Set `RUSTFS_RDMA_TOOLCHAIN` to select +an installed Rust toolchain or `CARGO_BUILD_JOBS` to limit parallelism. + Configure a verified HTTPS alias and start RustFS with its `nixl` Cargo feature and `RUSTFS_NIXL_ENABLE=true`. For a private CA, pass `--ca-bundle /path/to/ca.pem` to `rc alias set`. Set `RC_DATA_TRANSPORT=auto` @@ -47,74 +51,3 @@ round trip, set `RC` to the native executable and supply disposable buckets in `NIXL_BUCKET` and `HTTP_BUCKET` on enabled and disabled endpoints. Run `nixl/tests/interop.sh` with those variables. `UCX_TLS=tcp,self` exercises the protocol on a machine without an RDMA network adapter. - -## Private gateway protocol - -The normal workspace builds without access to the private transport repository: - -```sh -cargo build --release -p rustfs-cli -``` - -The optional build uses an independent manifest. Cargo resolves optional -dependencies even when their feature is disabled, so the normal workspace does -not declare a private path or Git dependency. - -An authorized developer enables the private build with: - -```sh -git submodule update --init vendor/rustfs-ucx -./scripts/build-rdma.sh --release -``` - -The equivalent Cargo command is: - -```sh -source vendor/rustfs-ucx/scripts/build-env.sh -cp -n Cargo.lock rdma/Cargo.lock -cargo +1.98.1 build --manifest-path rdma/Cargo.toml --features rdma --release -j 2 -``` - -The helper seeds a missing opt-in lockfile from the reviewed public CLI lockfile. -Cargo then adds private dependencies; an existing opt-in lockfile is preserved. - -The default output is `rdma/target/release/rc`. `RUSTFS_RDMA_TOOLCHAIN` selects -another installed toolchain satisfying the private dependency's MSRV, and -`CARGO_BUILD_JOBS` selects build parallelism. The submodule commit is pinned by -the parent repository; updating it is an explicit dependency update. - -Missing source causes the build helper to stop before invoking Cargo. Fetching -the private submodule requires repository authorization. The ordinary build does -not initialize it. The private startup entry installs the object data provider -and then runs the same public CLI launcher. - -`--data-transport http|auto|rdma` selects object payload policy. Its default is -`http`; management and metadata requests retain their existing transport. - -The public S3 client retains request options, signing, multipart management, -file publication and retry decisions. `rc-s3::data_transport` exposes the typed -provider and bounded signed-control interfaces. Transport implementation source -is compiled from the private submodule. - -The private provider discovers a matching gateway through a signed HTTPS HEAD -request before allocating transport resources or submitting an object write. -An endpoint which does not advertise the supported protocol version receives no -external-payload write. The provider then coordinates one signed S3 operation, -its external data, and its verified final result. - -Automatic selection may use HTTP only before the data operation is accepted or -supplied IO is polled. Explicit RDMA selection reports unavailable capability. -An unknown upload outcome cannot trigger a generic business retry. Multipart -creation, completion, and abort retain their existing S3 HTTPS implementation. - -The optional executable also defaults to HTTP. Use `--data-transport rdma` to -require the provider, or `--data-transport auto` to allow pre-admission fallback. -`RUSTFS_RDMA_OPERATION_TIMEOUT_SECONDS` sets the finite external operation -deadline, with a default of 3600 seconds. The private repository documents its -platform and runtime installation requirements. Successful interface tests do -not establish hardware throughput or latency. - -Install the matching native dependencies from the pinned private engine's -guide on both endpoints. Capability negotiation precedes external transfer -admission. Ambiguous write results use authenticated queries for the original -operation within its deadline; they do not resubmit the object or part. diff --git a/nixl/src/transport.rs b/nixl/src/transport.rs index 490374c2..77e1c43a 100644 --- a/nixl/src/transport.rs +++ b/nixl/src/transport.rs @@ -18,9 +18,9 @@ use crate::wire; pub(crate) struct Factory; impl ObjectDataTransportFactory for Factory { - fn create(&self, context: DataTransportContext) -> Result> { + fn create(&self, control: Arc) -> Result> { Ok(Arc::new(Transport { - control: context.control, + control, small_pool: OnceCell::new(), full_pool: OnceCell::new(), })) diff --git a/nixl/src/wire.rs b/nixl/src/wire.rs index fb36b5c7..0b089d7e 100644 --- a/nixl/src/wire.rs +++ b/nixl/src/wire.rs @@ -2,7 +2,7 @@ use http::{HeaderMap, HeaderValue, Method, StatusCode}; use rc_core::{Error, RemotePath, Result}; -use rc_s3::data_transport::{ControlPayload, ControlRequest}; +use rc_s3::data_transport::ControlRequest; use rustfs_nixl::{ NIXL_AGENT_HEADER, NIXL_BUFFER_HEADER, NIXL_METADATA_HEADER, RDMA_BYTES_TRANSFERRED_HEADER, RDMA_REPLY_HEADER, @@ -20,11 +20,7 @@ pub(crate) fn request( path: path.clone(), query, headers, - body: Default::default(), - payload: ControlPayload::External { - deadline: Instant::now() + Duration::from_secs(3600), - }, - response_limit: 64 * 1024, + deadline: Instant::now() + Duration::from_secs(3600), } } diff --git a/rdma/Cargo.toml b/rdma/Cargo.toml deleted file mode 100644 index f01a0f3c..00000000 --- a/rdma/Cargo.toml +++ /dev/null @@ -1,37 +0,0 @@ -[package] -name = "rustfs-cli-rdma" -version = "0.1.0" -edition = "2024" -rust-version = "1.98.1" -license = "Apache-2.0" -publish = false - -[workspace] -resolver = "3" - -[features] -default = [] -rdma = ["rustfs-ucx/object", "rustfs-ucx/native"] - -[lib] -path = "../vendor/rustfs-ucx/integrations/cli/src/lib.rs" - -[[bin]] -name = "rc" -path = "../vendor/rustfs-ucx/integrations/cli/src/main.rs" -required-features = ["rdma"] - -[dependencies] -rustfs-cli = { path = "../crates/cli" } -rc-core = { path = "../crates/core" } -rc-s3 = { path = "../crates/s3" } -rustfs-ucx = { path = "../vendor/rustfs-ucx", default-features = false } -async-trait = "0.1" -base64 = "0.22" -bytes = "1" -http = "1" -md-5 = "0.10" -thiserror = "2" -tokio = { version = "1", features = ["io-util", "macros", "rt", "sync", "time"] } -zeroize = "1" -tracing = { version = "0.1", default-features = false, features = ["std"] } diff --git a/scripts/build-rdma.sh b/scripts/build-rdma.sh index dcbf2a4f..1fa20305 100755 --- a/scripts/build-rdma.sh +++ b/scripts/build-rdma.sh @@ -1,21 +1,9 @@ #!/usr/bin/env bash set -euo pipefail -ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" -private="$ROOT_DIR/vendor/rustfs-ucx" -if [[ ! -f "$private/Cargo.toml" || ! -f "$private/integrations/cli/src/main.rs" || ! -f "$private/integrations/cli/src/lib.rs" || ! -f "$private/scripts/build-env.sh" ]]; then - printf '%s\n' 'RDMA requires the authorized private submodule vendor/rustfs-ucx.' >&2 - printf '%s\n' 'Run: git submodule update --init vendor/rustfs-ucx' >&2 - printf '%s\n' 'Authenticate with an account that can read rustfs/rustfs-ucx.' >&2 - exit 2 +root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" +toolchain=() +if [[ -n "${RUSTFS_RDMA_TOOLCHAIN:-}" ]]; then + toolchain=("+$RUSTFS_RDMA_TOOLCHAIN") fi - -source "$private/scripts/build-env.sh" - -if [[ ! -f "$ROOT_DIR/rdma/Cargo.lock" ]]; then - cp "$ROOT_DIR/Cargo.lock" "$ROOT_DIR/rdma/Cargo.lock" -fi - -exec cargo "+${RUSTFS_RDMA_TOOLCHAIN:-1.98.1}" build \ - --manifest-path "$ROOT_DIR/rdma/Cargo.toml" --features rdma \ - -j "${CARGO_BUILD_JOBS:-2}" "$@" +exec cargo "${toolchain[@]}" build --locked --manifest-path "$root_dir/nixl/Cargo.toml" "$@" diff --git a/scripts/tests/test_build_rdma.py b/scripts/tests/test_build_rdma.py index fc359b83..7b5274d7 100644 --- a/scripts/tests/test_build_rdma.py +++ b/scripts/tests/test_build_rdma.py @@ -1,102 +1,46 @@ #!/usr/bin/env python3 -"""Exercise the opt-in build boundary without loading a private dependency.""" +"""Check the Cargo invocation used to build the native RDMA executable.""" -from pathlib import Path import os -import shutil +from pathlib import Path import subprocess import tempfile import unittest +ROOT = Path(__file__).resolve().parents[2] + + class RdmaBuildTests(unittest.TestCase): def setUp(self): - self.temp = tempfile.TemporaryDirectory() - self.addCleanup(self.temp.cleanup) - self.root = Path(self.temp.name) - (self.root / "scripts").mkdir() - self.script = self.root / "scripts/build-rdma.sh" - shutil.copyfile(Path(__file__).parents[1] / "build-rdma.sh", self.script) - self.env = dict(os.environ) - self.env.pop("RUSTFS_RDMA_TOOLCHAIN", None) - self.env.pop("CARGO_BUILD_JOBS", None) - fake_bin = self.root / "bin" - fake_bin.mkdir() - cargo = fake_bin / "cargo" - cargo.write_text("#!/bin/sh\n[ \"${RUSTFS_PRIVATE_BUILD_PROBE:-}\" = enabled ] || exit 7\nprintf '%s\\n' \"$@\"\n") + temp = tempfile.TemporaryDirectory() + self.addCleanup(temp.cleanup) + self.cwd = Path(temp.name) + cargo = self.cwd / "cargo" + cargo.write_text("#!/bin/sh\nprintf '%s\\n' \"$@\"\nexit \"${CARGO_TEST_EXIT:-0}\"\n") cargo.chmod(0o755) - self.env["PATH"] = str(fake_bin) + os.pathsep + self.env["PATH"] + self.env = dict(os.environ, PATH=str(self.cwd) + os.pathsep + os.environ["PATH"]) + self.env.pop("RUSTFS_RDMA_TOOLCHAIN", None) def run_build(self, *args): - return subprocess.run(["bash", str(self.script), *args], env=self.env, - capture_output=True, text=True, check=False) - - def prepare_private(self): - (self.root / "rdma").mkdir() - (self.root / "Cargo.lock").write_text("version = 4\n") - private = self.root / "vendor/rustfs-ucx" - private.mkdir(parents=True) - (private / "Cargo.toml").write_text('[package]\nname = "rustfs-ucx"\n') - entry = private / "integrations/cli/src/main.rs" - entry.parent.mkdir(parents=True) - entry.write_text("// Fixture: only the build preflight reads this path.\n") - (entry.parent / "lib.rs").touch() - (private / "scripts").mkdir() - (private / "scripts/build-env.sh").write_text("export RUSTFS_PRIVATE_BUILD_PROBE=enabled\n") + return subprocess.run( + [str(ROOT / "scripts/build-rdma.sh"), *args], + cwd=self.cwd, env=self.env, capture_output=True, text=True, check=False, + ) - def test_missing_private_source_fails_before_cargo(self): - result = self.run_build() - self.assertEqual(result.returncode, 2) - self.assertIn("private submodule", result.stderr) - self.assertEqual(result.stdout, "") - - def test_partial_checkout_is_rejected(self): - private = self.root / "vendor/rustfs-ucx" - private.mkdir(parents=True) - (private / "Cargo.toml").write_text('[package]\nname = "rustfs-ucx"\n') - result = self.run_build() - self.assertEqual(result.returncode, 2) - self.assertIn("private submodule", result.stderr) - self.assertEqual(result.stdout, "") - - def test_entry_without_manifest_is_rejected(self): - self.prepare_private() - (self.root / "vendor/rustfs-ucx/Cargo.toml").unlink() - result = self.run_build() - self.assertEqual(result.returncode, 2) - self.assertEqual(result.stdout, "") - - def test_missing_private_build_environment_is_rejected(self): - self.prepare_private() - (self.root / "vendor/rustfs-ucx/scripts/build-env.sh").unlink() - result = self.run_build() - self.assertEqual(result.returncode, 2) - self.assertEqual(result.stdout, "") - - def test_opt_in_preserves_arguments_and_uses_separate_manifest(self): - self.prepare_private() - result = self.run_build("--release", "--offline") + def test_builds_locked_native_package_and_forwards_arguments(self): + result = self.run_build("--release", "--target-dir", "build dir") self.assertEqual(result.returncode, 0, result.stderr) - self.assertEqual(result.stdout.splitlines(), ["+1.98.1", "build", "--manifest-path", - str(self.root / "rdma/Cargo.toml"), "--features", "rdma", "-j", "2", - "--release", "--offline"]) + self.assertEqual(result.stdout.splitlines(), [ + "build", "--locked", "--manifest-path", str(ROOT / "nixl/Cargo.toml"), + "--release", "--target-dir", "build dir", + ]) - def test_toolchain_and_parallelism_are_explicit(self): - self.prepare_private() - self.env["RUSTFS_RDMA_TOOLCHAIN"] = "stable" - self.env["CARGO_BUILD_JOBS"] = "3" + def test_explicit_toolchain_and_cargo_exit_status(self): + self.env.update(RUSTFS_RDMA_TOOLCHAIN="stable", CARGO_TEST_EXIT="17") result = self.run_build() - self.assertEqual(result.returncode, 0, result.stderr) + self.assertEqual(result.returncode, 17, result.stderr) self.assertEqual(result.stdout.splitlines()[0], "+stable") - self.assertEqual(result.stdout.splitlines()[-2:], ["-j", "3"]) - - def test_existing_rdma_lock_is_preserved(self): - self.prepare_private() - lock = self.root / "rdma/Cargo.lock" - lock.write_text("version = 4\n# independent resolution\n") - result = self.run_build() - self.assertEqual(result.returncode, 0, result.stderr) - self.assertEqual(lock.read_text(), "version = 4\n# independent resolution\n") if __name__ == "__main__": diff --git a/vendor/rustfs-ucx b/vendor/rustfs-ucx deleted file mode 160000 index 32208f0b..00000000 --- a/vendor/rustfs-ucx +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 32208f0b9cdf748843f1344ae4bd433372b8521f From d2362d378bba0bdc4ea9f2943e423c883d7735e4 Mon Sep 17 00:00:00 2001 From: GatewayJ <835269233@qq.com> Date: Fri, 20 Nov 2026 20:04:09 +0800 Subject: [PATCH 3/5] fix(phase-3): preserve S3 read policy and renew NIXL windows --- .github/scripts/build-nixl-runtime.sh | 30 +++++ .github/workflows/nixl.yml | 53 +++++++++ crates/s3/src/client.rs | 106 +++++++----------- crates/s3/src/data_transport.rs | 1 - docs/ADR/0001-object-data-transport.md | 2 +- docs/rdma-build.md | 14 ++- nixl/src/pool.rs | 145 +++++++++++++++++++------ nixl/src/transport.rs | 32 ++---- nixl/src/transport/download.rs | 56 +++++----- nixl/src/transport/tests.rs | 82 ++++++++++++++ nixl/src/transport/upload.rs | 50 +++++---- nixl/src/wire.rs | 2 - nixl/src/wire/native_test.rs | 19 +--- 13 files changed, 401 insertions(+), 191 deletions(-) create mode 100755 .github/scripts/build-nixl-runtime.sh create mode 100644 .github/workflows/nixl.yml create mode 100644 nixl/src/transport/tests.rs diff --git a/.github/scripts/build-nixl-runtime.sh b/.github/scripts/build-nixl-runtime.sh new file mode 100755 index 00000000..9541310e --- /dev/null +++ b/.github/scripts/build-nixl-runtime.sh @@ -0,0 +1,30 @@ +#!/usr/bin/env bash +# Build a CPU-only UCX runtime for the native CLI test job. +set -euo pipefail + +: "${NIXL_PREFIX:?set the installation prefix}" +build_dir=$(mktemp -d) +trap 'rm -rf "$build_dir"' EXIT +jobs=${CARGO_BUILD_JOBS:-4} +manifest=$(cargo metadata --locked --manifest-path nixl/Cargo.toml --format-version 1 --filter-platform x86_64-unknown-linux-gnu | + jq -er '.packages[] | select(.name == "nixl-sys") | .manifest_path') +source_dir=$(git -C "$(dirname "$manifest")" rev-parse --show-toplevel) + +cd "$build_dir" +curl --fail --location --retry 3 --output ucx.tar.gz https://github.com/openucx/ucx/releases/download/v1.22.0/ucx-1.22.0.tar.gz +echo '258941cddd14ca60d38c0d31b9b09ec1052c901086841011a498da8b55a3cb24 ucx.tar.gz' | sha256sum --check +tar -xzf ucx.tar.gz +( + cd ucx-1.22.0 + ./configure --prefix="$NIXL_PREFIX" --enable-mt --without-cuda --without-rocm --without-java --without-go --disable-numa --disable-examples + make -j"$jobs" + make install +) + +# Meson can populate subprojects. Leave Cargo's reviewed dependency checkout intact. +git -C "$source_dir" archive HEAD | tar -x -C "$build_dir" +meson setup "$build_dir/build" "$build_dir" --prefix "$NIXL_PREFIX" --libdir lib \ + -Ducx_path="$NIXL_PREFIX" -Denable_plugins=UCX -Dinstall_headers=true \ + -Dbuild_tests=false -Dbuild_examples=false -Dbuild_nixl_ep=false -Dwith_trace=false +meson compile -C "$build_dir/build" -j "$jobs" +meson install -C "$build_dir/build" diff --git a/.github/workflows/nixl.yml b/.github/workflows/nixl.yml new file mode 100644 index 00000000..59f216fe --- /dev/null +++ b/.github/workflows/nixl.yml @@ -0,0 +1,53 @@ +name: Native NIXL client + +on: + workflow_dispatch: + pull_request: + paths: + - 'nixl/**' + - 'crates/**' + - 'Cargo.toml' + - 'Cargo.lock' + - 'scripts/build-rdma.sh' + - '.github/scripts/build-nixl-runtime.sh' + - '.github/workflows/nixl.yml' + +permissions: + contents: read + +jobs: + native: + runs-on: ubuntu-24.04 + timeout-minutes: 75 + env: + CARGO_PROFILE_DEV_DEBUG: '0' + CARGO_PROFILE_TEST_DEBUG: '0' + CARGO_INCREMENTAL: '0' + UCX_TLS: tcp,self + NIXL_NO_STUBS_FALLBACK: '1' + steps: + - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6 + - uses: dtolnay/rust-toolchain@4be7066ada62dd38de10e7b70166bc74ed198c30 # stable + - uses: Swatinem/rust-cache@e18b497796c12c097a38f9edb9d0641fb99eee32 # v2 + with: + workspaces: nixl + - name: Install native build tools + run: | + echo "NIXL_PREFIX=$RUNNER_TEMP/nixl" >> "$GITHUB_ENV" + sudo apt-get update + sudo apt-get install -y --no-install-recommends libclang-dev ninja-build meson + - name: Cache the UCX and NIXL runtime + id: native-cache + uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6 + with: + path: ${{ runner.temp }}/nixl + key: nixl-ubuntu-24.04-${{ runner.arch }}-${{ hashFiles('nixl/Cargo.lock', '.github/scripts/build-nixl-runtime.sh') }} + - name: Build UCX and the NIXL revision from Cargo.lock + if: steps.native-cache.outputs.cache-hit != 'true' + run: .github/scripts/build-nixl-runtime.sh + - name: Build and test the native client over UCX loopback + run: | + export LD_LIBRARY_PATH="$NIXL_PREFIX/lib" + export NIXL_PLUGIN_DIR="$NIXL_PREFIX/lib/plugins" + ./scripts/build-rdma.sh + cargo test --locked --manifest-path nixl/Cargo.toml diff --git a/crates/s3/src/client.rs b/crates/s3/src/client.rs index 1d8d2fb5..a4cbb53f 100644 --- a/crates/s3/src/client.rs +++ b/crates/s3/src/client.rs @@ -251,25 +251,6 @@ async fn build_reqwest_client( client_cert: Option<&str>, client_key: Option<&str>, timeout: Option<&rc_core::alias::TimeoutConfig>, -) -> Result { - build_reqwest_client_with_read_policy( - insecure, - ca_bundle, - client_cert, - client_key, - timeout, - true, - ) - .await -} - -async fn build_reqwest_client_with_read_policy( - insecure: bool, - ca_bundle: Option<&str>, - client_cert: Option<&str>, - client_key: Option<&str>, - timeout: Option<&rc_core::alias::TimeoutConfig>, - apply_read_timeout: bool, ) -> Result { // NOTE: When `insecure = true`, `danger_accept_invalid_certs` disables all TLS // certificate verification. Any CA bundle provided will still be added to the @@ -280,9 +261,7 @@ async fn build_reqwest_client_with_read_policy( if let Some(timeout) = timeout { builder = builder.connect_timeout(Duration::from_millis(timeout.connect_ms)); - if apply_read_timeout { - builder = builder.read_timeout(Duration::from_millis(timeout.read_ms)); - } + builder = builder.read_timeout(Duration::from_millis(timeout.read_ms)); } if let Some(bundle_path) = ca_bundle { @@ -1789,7 +1768,6 @@ pub struct S3Client { inner: aws_sdk_s3::Client, presign_inner: aws_sdk_s3::Client, xml_http_client: reqwest::Client, - external_http_client: Arc>, alias: Alias, session_token: Option, request_headers: Vec, @@ -1915,7 +1893,6 @@ impl S3Client { inner: client, presign_inner: presign_client, xml_http_client, - external_http_client: Arc::new(tokio::sync::OnceCell::new()), alias, session_token, request_headers, @@ -7845,18 +7822,6 @@ impl ControlExecutor for S3Client { "External object control requires an authenticated S3 principal".to_string(), )); } - let remaining = || { - request - .deadline - .checked_duration_since(std::time::Instant::now()) - .filter(|duration| !duration.is_zero()) - .ok_or_else(|| { - Error::RequestRejected( - "The external control operation deadline has elapsed".to_string(), - ) - }) - }; - remaining()?; let url = self.external_control_url(&request.path, &request.query)?; let mut headers = request.headers; for name in [ @@ -7910,27 +7875,26 @@ impl ControlExecutor for S3Client { std::time::SystemTime::now(), ) .await?; - let client = self - .external_http_client - .get_or_try_init(|| async { - build_reqwest_client_with_read_policy( - self.alias.insecure, - self.alias.ca_bundle.as_deref(), - self.alias.client_cert.as_deref(), - self.alias.client_key.as_deref(), - self.alias.timeout.as_ref(), - false, - ) - .await - }) - .await?; - let mut response = client + // Only response headers travel over HTTPS. Bound the complete wait, + // including connection setup, using the same alias policy as S3. + let timeout = self.alias.timeout_config(); + let mut response = self + .xml_http_client .request(request.method, url) .headers(signed) - .timeout(remaining()?) + .timeout(Duration::from_millis( + timeout.connect_ms.saturating_add(timeout.read_ms), + )) .send() .await - .map_err(|_| Error::Network("External control exchange failed".to_string()))?; + .map_err(|error| { + let message = if error.is_timeout() { + "Timed out waiting for the S3 control response" + } else { + "External control exchange failed" + }; + Error::Network(message.to_owned()) + })?; Ok(ControlResponse { status: response.status(), headers: std::mem::take(response.headers_mut()), @@ -8104,7 +8068,6 @@ mod tests { inner: aws_sdk_s3::Client::from_conf(config), presign_inner: aws_sdk_s3::Client::from_conf(presign_config), xml_http_client, - external_http_client: Arc::new(tokio::sync::OnceCell::new()), alias, session_token: None, request_headers, @@ -8164,7 +8127,6 @@ mod tests { inner: aws_sdk_s3::Client::from_conf(config), presign_inner: aws_sdk_s3::Client::from_conf(presign_config), xml_http_client: reqwest::Client::new(), - external_http_client: Arc::new(tokio::sync::OnceCell::new()), alias, session_token: None, request_headers, @@ -8297,7 +8259,6 @@ mod tests { inner: aws_sdk_s3::Client::from_conf(config.clone()), presign_inner: aws_sdk_s3::Client::from_conf(config), xml_http_client: reqwest::Client::new(), - external_http_client: Arc::new(tokio::sync::OnceCell::new()), alias, session_token: None, request_headers: Vec::new(), @@ -15596,7 +15557,6 @@ mod tests { path: RemotePath::new("test", "bucket", "key"), query: Vec::new(), headers: HeaderMap::new(), - deadline: Instant::now() + Duration::from_secs(30), }; assert!(matches!( ControlExecutor::execute_headers(&client, request).await, @@ -15606,21 +15566,33 @@ mod tests { } #[tokio::test] - async fn external_control_rejects_an_elapsed_operation_deadline_before_network_io() { - let (client, replay) = test_s3_client_with_response_sequence(Vec::new()); + async fn external_control_honors_alias_timeouts() { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0") + .await + .expect("listen"); + let endpoint = format!("https://{}", listener.local_addr().expect("port")); + let (mut client, _) = test_s3_client_with_endpoint(&endpoint, None); + client.xml_http_client = reqwest::Client::builder() + .no_proxy() + .build() + .expect("loopback HTTP client"); + client.alias.timeout = Some(rc_core::alias::TimeoutConfig { + connect_ms: 150, + read_ms: 150, + }); let request = ControlRequest { - method: Method::PUT, + method: Method::HEAD, path: RemotePath::new("test", "bucket", "key"), query: Vec::new(), headers: HeaderMap::new(), - deadline: Instant::now(), }; - assert!(matches!( - ControlExecutor::execute_headers(&client, request).await, - Err(Error::RequestRejected(_)) - )); - assert_eq!(replay.actual_requests().count(), 0); - assert!(client.external_http_client.get().is_none()); + let (result, connection) = tokio::time::timeout(Duration::from_secs(3), async { + tokio::join!(client.execute_headers(request), listener.accept()) + }) + .await + .expect("the alias deadline must end a stalled TLS exchange"); + assert!(connection.is_ok()); + assert!(matches!(result, Err(Error::Network(message)) if message.contains("Timed out"))); } #[tokio::test] diff --git a/crates/s3/src/data_transport.rs b/crates/s3/src/data_transport.rs index b187f74e..2dd3ff59 100644 --- a/crates/s3/src/data_transport.rs +++ b/crates/s3/src/data_transport.rs @@ -25,7 +25,6 @@ pub struct ControlRequest { pub path: RemotePath, pub query: Vec<(String, String)>, pub headers: HeaderMap, - pub deadline: std::time::Instant, } /// Uninterpreted control response; duplicate and binary headers are preserved. diff --git a/docs/ADR/0001-object-data-transport.md b/docs/ADR/0001-object-data-transport.md index f48b8b05..6f9955ab 100644 --- a/docs/ADR/0001-object-data-transport.md +++ b/docs/ADR/0001-object-data-transport.md @@ -15,7 +15,7 @@ existing worker-thread configuration. The provider supplies NIXL agent metadata and a registered buffer description to a host-owned `ControlExecutor`. The S3 client signs and sends a bodyless -HTTPS request with a deadline. It returns the status and headers directly, +HTTPS request on the shared S3 HTTP client using the alias timeout policy. It returns the status and headers directly, including duplicate headers. The provider verifies the RustFS transfer receipt and byte count. Credentials, endpoint addressing, custom headers, and TLS remain in the S3 client. diff --git a/docs/rdma-build.md b/docs/rdma-build.md index 06677102..7eba4c1f 100644 --- a/docs/rdma-build.md +++ b/docs/rdma-build.md @@ -7,8 +7,8 @@ NIXL libraries, headers and UCX plugin used by the RustFS server. Set `NIXL_PREFIX` to the native installation before building. At runtime set `LD_LIBRARY_PATH` to include its library directory and `NIXL_PLUGIN_DIR` to its plugin directory. Set `UCX_NET_DEVICES` to select client network devices -when needed. The native package pins the same `rustfs-nixl` and -`nixl-sys` sources as the server. +when needed. The native manifest pins the public RustFS library revision, and its lockfile +pins the corresponding NIXL bindings. ```sh ./scripts/build-rdma.sh --release @@ -24,16 +24,20 @@ an installed Rust toolchain or `CARGO_BUILD_JOBS` to limit parallelism. Configure a verified HTTPS alias and start RustFS with its `nixl` Cargo feature and `RUSTFS_NIXL_ENABLE=true`. For a private CA, pass `--ca-bundle /path/to/ca.pem` to `rc alias set`. Set `RC_DATA_TRANSPORT=auto` -or `rdma` to reuse the selection across commands. The default is `http`. +or `rdma` to reuse the selection across commands. The default is `http`. Signed control requests use the alias connection and +read timeouts, including the wait for each transfer receipt. File uploads use positional reads directly into two reusable registered windows. For transfers of up to 1 MiB, the client can register two 1 MiB windows. Larger transfers use 64 MiB windows, which also serve subsequent small requests on the same client. File downloads write directly into the temporary destination file. A range GET for the next window can proceed while the -previous window is being written. The client selects a version and uses -`If-Match` to keep ranges consistent. Downloads publish the temporary file +previous window is being written. All requests keep the caller's version selector. Each GET uses +`If-Match` and checks the version from HEAD before delivering that range. Downloads publish the temporary file after verifying the transfer count and any applicable object checksum. +A window with an uncertain transfer stays registered until the process exits. +When both windows are unavailable for this reason, waiting operations use a +fresh pool within the process registration budget. RustFS can interpret a declined external PUT as an ordinary empty PUT. The client uploads nonempty objects into unpublished multipart parts and diff --git a/nixl/src/pool.rs b/nixl/src/pool.rs index c3646f72..dfa87260 100644 --- a/nixl/src/pool.rs +++ b/nixl/src/pool.rs @@ -1,28 +1,74 @@ //! Registered host memory and ownership while the server can access it. use base64::{Engine, engine::general_purpose::STANDARD}; -use http::HeaderValue; +use http::{HeaderMap, HeaderValue}; use rc_core::{Error, Result}; use rustfs_nixl::{NixlConfig, NixlServer, StagingChunk}; use std::sync::{Arc, Mutex}; use std::time::Duration; -use tokio::sync::{Semaphore, SemaphorePermit}; +use tokio::sync::{Mutex as AsyncMutex, Semaphore, SemaphorePermit, watch}; pub(crate) const WINDOW: usize = rc_s3::multipart::DEFAULT_PART_SIZE as usize; pub(crate) const SMALL_WINDOW: usize = 1024 * 1024; // Two windows allow the next network read to overlap the previous file write. static AGENTS: Semaphore = Semaphore::const_new(8); -static QUARANTINE: Mutex)>> = Mutex::new(Vec::new()); +static QUARANTINE: Mutex> = Mutex::new(Vec::new()); +const WINDOWS_PER_POOL: usize = 2; -pub(crate) struct Pool { +/// One active registration per S3 client. A larger request upgrades the pool; +/// outstanding windows keep their original registration alive. +#[derive(Default)] +pub(crate) struct Pools { + active: AsyncMutex>>, +} + +impl Pools { + pub(crate) async fn reserve(&self, required: u64) -> Result { + let size = if required <= SMALL_WINDOW as u64 { + SMALL_WINDOW + } else { + WINDOW + }; + loop { + let pool = { + let mut active = self.active.lock().await; + if let Some(pool) = active.as_ref() + && pool.agent.chunk_bytes() >= size + && *pool.lost.borrow() < WINDOWS_PER_POOL + { + pool.clone() + } else { + let pool = tokio::task::spawn_blocking(move || Pool::open(size)) + .await + .map_err(|_| { + Error::General("NIXL agent startup was interrupted".into()) + })??; + *active = Some(pool.clone()); + pool + } + }; + let mut lost = pool.lost.subscribe(); + tokio::select! { + biased; + _ = lost.wait_for(|count| *count == WINDOWS_PER_POOL) => continue, + result = pool.agent.reserve(Duration::from_secs(60)) => { + return Ok(Window { chunk: result.map_err(native_error)?, pool }); + } + } + } + } +} + +struct Pool { + lost: watch::Sender, agent: Arc, - pub(crate) name: HeaderValue, - pub(crate) metadata: HeaderValue, + name: HeaderValue, + metadata: HeaderValue, _budget: SemaphorePermit<'static>, } impl Pool { - pub(crate) fn open(window: usize) -> Result> { + fn open(window: usize) -> Result> { let budget = AGENTS .try_acquire() .map_err(|_| Error::General("NIXL registered memory budget exhausted".into()))?; @@ -32,7 +78,7 @@ impl Pool { let agent = NixlServer::new(&NixlConfig { agent_name: name.clone(), chunk_bytes: window, - pool_bytes: 2 * window, + pool_bytes: WINDOWS_PER_POOL * window, ..NixlConfig::default() }) .map_err(native_error)?; @@ -44,51 +90,86 @@ impl Pool { agent, name: HeaderValue::from_str(&name).expect("ASCII agent ID"), metadata, + lost: watch::Sender::new(0), _budget: budget, })) } - - pub(crate) async fn reserve(&self) -> Result { - self.agent - .reserve(Duration::from_secs(60)) - .await - .map_err(native_error) - } } pub(crate) fn native_error(error: rustfs_nixl::NixlError) -> Error { Error::General(format!("NIXL/UCX: {error}")) } -/// A cancelled or interrupted HTTPS exchange gives no proof that peer DMA has -/// finished. Such windows retain their registration and its budget until exit. -pub(crate) struct Exposed { - chunk: Option, +pub(crate) struct Window { + pub(crate) chunk: StagingChunk, pool: Arc, } -impl Exposed { - pub(crate) fn new(chunk: StagingChunk, pool: Arc) -> Self { - Self { - chunk: Some(chunk), - pool, - } +impl Window { + pub(crate) fn bind(&self, headers: &mut HeaderMap, len: usize) -> Result<()> { + crate::wire::bind( + headers, + &self.pool.name, + &self.pool.metadata, + self.chunk.addr(), + len, + ) } - pub(crate) fn finished(mut self) -> StagingChunk { - self.chunk - .take() - .expect("exposed window is owned until completion") + pub(crate) fn expose(self) -> Exposed { + Exposed(Some(self)) + } +} + +/// Until a receipt proves completion, cancellation must retain the address +/// and its registration. The process registration budget also covers this list. +pub(crate) struct Exposed(Option); + +impl Exposed { + pub(crate) fn finished(mut self) -> Window { + self.0.take().expect("owned NIXL window") } } impl Drop for Exposed { fn drop(&mut self) { - if let Some(chunk) = self.chunk.take() { + if let Some(window) = self.0.take() { + window.pool.lost.send_modify(|lost| *lost += 1); QUARANTINE .lock() - .unwrap_or_else(|p| p.into_inner()) - .push((chunk, self.pool.clone())); + .unwrap_or_else(|err| err.into_inner()) + .push(window); } } } + +#[cfg(test)] +mod tests { + use super::*; + + #[tokio::test] + async fn uncertain_windows_wake_waiters_and_cannot_be_reissued() { + let pools = Pools::default(); + let first = pools.reserve(32).await.unwrap(); + let second = pools.reserve(32).await.unwrap(); + let old = first.pool.clone(); + assert!(Arc::ptr_eq(&old, &second.pool)); + let waiting = pools.reserve(32); + tokio::pin!(waiting); + assert!( + tokio::time::timeout(Duration::from_millis(5), &mut waiting) + .await + .is_err() + ); + drop(first.expose()); + drop(second.expose()); + let replacement = tokio::time::timeout(Duration::from_secs(10), waiting) + .await + .unwrap() + .unwrap(); + assert!(!Arc::ptr_eq(&old, &replacement.pool)); + let returned = replacement.expose().finished(); + drop(returned); + assert!(old.agent.try_reserve().is_none()); + } +} diff --git a/nixl/src/transport.rs b/nixl/src/transport.rs index 77e1c43a..2033f831 100644 --- a/nixl/src/transport.rs +++ b/nixl/src/transport.rs @@ -7,12 +7,11 @@ use async_trait::async_trait; use http::{HeaderMap, HeaderValue, Method, StatusCode}; use rc_core::{DataTransferState, Error, ObjectInfo, RemotePath, Result}; use rc_s3::data_transport::*; -use rustfs_nixl::{RDMA_REPLY_HEADER, StagingChunk}; +use rustfs_nixl::RDMA_REPLY_HEADER; use std::sync::Arc; use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; -use tokio::sync::OnceCell; -use crate::pool::{Exposed, Pool, SMALL_WINDOW, WINDOW, native_error}; +use crate::pool::{Exposed, Pools, WINDOW, Window, native_error}; use crate::wire; pub(crate) struct Factory; @@ -21,16 +20,14 @@ impl ObjectDataTransportFactory for Factory { fn create(&self, control: Arc) -> Result> { Ok(Arc::new(Transport { control, - small_pool: OnceCell::new(), - full_pool: OnceCell::new(), + pools: Pools::default(), })) } } struct Transport { control: Arc, - small_pool: OnceCell>, - full_pool: OnceCell>, + pools: Pools, } fn failed(state: DataTransferState, source: Error) -> DataTransportError { @@ -67,24 +64,6 @@ impl Transport { Err(error) => Err(unknown(error)), } } - - async fn pool(&self, required: u64) -> DataTransportResult<&Arc> { - if let Some(pool) = self.full_pool.get() { - return Ok(pool); - } - let (slot, window) = if required <= SMALL_WINDOW as u64 { - (&self.small_pool, SMALL_WINDOW) - } else { - (&self.full_pool, WINDOW) - }; - slot.get_or_try_init(|| async { - tokio::task::spawn_blocking(move || Pool::open(window)) - .await - .map_err(|_| Error::General("NIXL agent startup was interrupted".into()))? - }) - .await - .map_err(unavailable) - } } #[async_trait] @@ -120,3 +99,6 @@ impl ObjectDataTransport for Transport { self.upload_reader(request, source).await } } + +#[cfg(test)] +mod tests; diff --git a/nixl/src/transport/download.rs b/nixl/src/transport/download.rs index eedb2acc..aa76259b 100644 --- a/nixl/src/transport/download.rs +++ b/nixl/src/transport/download.rs @@ -10,6 +10,7 @@ struct Selection<'a> { query: Vec<(String, String)>, total: u64, etag: HeaderValue, + version: Option<&'a str>, } impl Transport { @@ -19,8 +20,7 @@ impl Transport { offset: u64, len: usize, ranged: bool, - ) -> DataTransportResult { - let pool = self.pool(len as u64).await?; + ) -> DataTransportResult { let mut headers = HeaderMap::new(); headers.insert("if-match", selection.etag.clone()); let expected = if ranged { @@ -33,17 +33,10 @@ impl Transport { } else { StatusCode::OK }; - let chunk = pool.reserve().await.map_err(unavailable)?; - // A zero-byte object still needs a valid, nonempty NIXL descriptor. - wire::bind( - &mut headers, - &pool.name, - &pool.metadata, - chunk.addr(), - len.max(1), - ) - .map_err(unavailable)?; - let exposed = Exposed::new(chunk, pool.clone()); + let window = self.pools.reserve(len as u64).await.map_err(unavailable)?; + // An empty object still requires a nonempty descriptor. + window.bind(&mut headers, len.max(1)).map_err(unavailable)?; + let exposed = window.expose(); let (response, exposed) = self .exchange( wire::request( @@ -72,7 +65,7 @@ impl Transport { ))); } wire::receipt(expected, &response.headers, len as u64).map_err(rejected)?; - let mut chunk = exposed.finished(); + let mut window = exposed.finished(); if wire::field(&response.headers, "content-length") .map_err(rejected)? .is_some_and(|value| value != "0") @@ -81,6 +74,14 @@ impl Transport { "NIXL GET returned an HTTP payload".into(), ))); } + if wire::field(&response.headers, "x-amz-version-id").map_err(rejected)? + != selection.version + { + return Err(rejected(Error::Conflict(format!( + "Object version changed: {}", + selection.path + )))); + } if ranged { let expected_range = format!( "bytes {offset}-{}/{}", @@ -95,8 +96,12 @@ impl Transport { ))); } } - chunk.advance(len).map_err(native_error).map_err(rejected)?; - Ok(chunk) + window + .chunk + .advance(len) + .map_err(native_error) + .map_err(rejected)?; + Ok(window) } pub(super) async fn download_into( @@ -140,12 +145,7 @@ impl Transport { "NIXL object exceeds the receive bound".into(), ))); } - if query.is_empty() - && let Some(version) = - wire::field(&head.headers, "x-amz-version-id").map_err(rejected)? - { - query.push(("versionId".into(), version.into())); - } + let version = wire::field(&head.headers, "x-amz-version-id").map_err(rejected)?; let etag = head .headers .get("etag") @@ -156,6 +156,7 @@ impl Transport { query, total, etag, + version, }; let ranged = length > 0 && (request.max_bytes.is_some() || length > WINDOW as u64); let first = length.min(WINDOW as u64) as usize; @@ -165,20 +166,23 @@ impl Transport { loop { let write = async { if length == total { - checksum.update(current.staged().map_err(native_error)?); + checksum.update(current.chunk.staged().map_err(native_error)?); } - let offset = end - current.len() as u64; + let offset = end - current.chunk.len() as u64; match &mut target { Sink::Writer(writer) => { writer - .write_all(current.staged().map_err(native_error)?) + .write_all(current.chunk.staged().map_err(native_error)?) .await? } Sink::File(file) => { use std::os::unix::fs::FileExt; let file = file.clone(); tokio::task::spawn_blocking(move || { - file.write_all_at(current.staged().map_err(native_error)?, offset)?; + file.write_all_at( + current.chunk.staged().map_err(native_error)?, + offset, + )?; Ok::<_, Error>(()) }) .await diff --git a/nixl/src/transport/tests.rs b/nixl/src/transport/tests.rs new file mode 100644 index 00000000..e88bd545 --- /dev/null +++ b/nixl/src/transport/tests.rs @@ -0,0 +1,82 @@ +use super::*; +use std::sync::Mutex; + +struct VersionedObject { + queries: Mutex>>, + get_version: &'static str, +} + +#[async_trait] +impl ControlExecutor for VersionedObject { + async fn execute_headers(&self, request: ControlRequest) -> Result { + self.queries.lock().unwrap().push(request.query); + let mut headers = HeaderMap::new(); + let version = if request.method == Method::HEAD { + "v1" + } else { + assert_eq!(request.headers["if-match"], "\"etag\""); + headers.insert(RDMA_REPLY_HEADER, HeaderValue::from_static("200")); + self.get_version + }; + headers.insert("etag", HeaderValue::from_static("\"etag\"")); + headers.insert("content-length", HeaderValue::from_static("0")); + headers.insert("x-amz-version-id", HeaderValue::from_static(version)); + Ok(ControlResponse { + status: StatusCode::OK, + headers, + }) + } +} + +async fn download( + version_id: Option<&str>, + get_version: &'static str, +) -> (DataTransportResult, Arc) { + let endpoint = Arc::new(VersionedObject { + queries: Mutex::default(), + get_version, + }); + let transport = Factory.create(endpoint.clone()).unwrap(); + let path = RemotePath::new("test", "bucket", "key"); + let options = rc_core::TransferReadOptions { + version_id: version_id.map(str::to_owned), + ..Default::default() + }; + let result = transport + .download( + DownloadRequest { + path: &path, + options: &options, + max_bytes: None, + max_receive_bytes: 4096, + on_progress: &mut |_, _| {}, + }, + &mut tokio::io::sink(), + ) + .await; + (result, endpoint) +} + +#[tokio::test] +async fn current_and_explicit_version_keep_the_callers_selector() { + for selector in [None, Some("v1")] { + let (result, endpoint) = download(selector, "v1").await; + assert!(result.is_ok()); + let query: Vec<_> = selector + .map(|v| ("versionId".to_owned(), v.to_owned())) + .into_iter() + .collect(); + assert_eq!( + *endpoint.queries.lock().unwrap(), + vec![query.clone(), query] + ); + } +} + +#[tokio::test] +async fn replacement_with_the_same_etag_is_detected_before_writing() { + let (result, _) = download(None, "v2").await; + assert!( + matches!(result, Err(error) if matches!(error.source.as_deref(), Some(Error::Conflict(_)))) + ); +} diff --git a/nixl/src/transport/upload.rs b/nixl/src/transport/upload.rs index 707e60c9..d4a83296 100644 --- a/nixl/src/transport/upload.rs +++ b/nixl/src/transport/upload.rs @@ -7,9 +7,13 @@ impl Transport { source: &mut (dyn AsyncRead + Unpin + Send), ) -> DataTransportResult { let len = part_len(&request)?; - let pool = self.pool(request.content_length).await?; - let mut chunk = pool.reserve().await.map_err(unavailable)?; - let dest = chunk + let mut window = self + .pools + .reserve(request.content_length) + .await + .map_err(unavailable)?; + let dest = window + .chunk .spare_mut() .map_err(native_error) .map_err(unavailable)?; @@ -29,7 +33,7 @@ impl Transport { "NIXL part source exceeds its declared length".into(), ))); } - self.send_part(&request, pool, chunk) + self.send_part(&request, window) .await? .ok_or_else(declined_part) } @@ -64,9 +68,13 @@ impl StagedUploadTransport for Transport { upload_id: &str, first_part_bytes: u64, ) -> DataTransportResult { - let pool = self.pool(first_part_bytes).await?; - let mut chunk = pool.reserve().await.map_err(unavailable)?; - chunk + let mut window = self + .pools + .reserve(first_part_bytes) + .await + .map_err(unavailable)?; + window + .chunk .append(&[0]) .map_err(native_error) .map_err(unavailable)?; @@ -81,7 +89,7 @@ impl StagedUploadTransport for Transport { }, checksum_sha256: None, }; - Ok(self.send_part(&request, pool, chunk).await?.is_some()) + Ok(self.send_part(&request, window).await?.is_some()) } async fn upload_file_part( @@ -92,16 +100,22 @@ impl StagedUploadTransport for Transport { ) -> DataTransportResult { use std::os::unix::fs::FileExt; let len = part_len(&request)?; - let pool = self.pool(request.content_length).await?; - let mut chunk = pool.reserve().await.map_err(unavailable)?; - let chunk = tokio::task::spawn_blocking(move || { - file.read_exact_at(&mut chunk.spare_mut().map_err(native_error)?[..len], offset)?; - Ok::<_, Error>(chunk) + let mut window = self + .pools + .reserve(request.content_length) + .await + .map_err(unavailable)?; + let window = tokio::task::spawn_blocking(move || { + file.read_exact_at( + &mut window.chunk.spare_mut().map_err(native_error)?[..len], + offset, + )?; + Ok::<_, Error>(window) }) .await .map_err(|_| rejected(Error::General("NIXL file read was interrupted".into())))? .map_err(rejected)?; - self.send_part(&request, pool, chunk) + self.send_part(&request, window) .await? .ok_or_else(declined_part) } @@ -111,8 +125,7 @@ impl Transport { async fn send_part( &self, request: &UploadRequest<'_>, - pool: &Arc, - chunk: StagingChunk, + window: Window, ) -> DataTransportResult> { let UploadOperation::UploadPart { upload_id, @@ -125,13 +138,12 @@ impl Transport { }; let len = part_len(request)?; let mut headers = HeaderMap::new(); - wire::bind(&mut headers, &pool.name, &pool.metadata, chunk.addr(), len) - .map_err(unavailable)?; + window.bind(&mut headers, len).map_err(unavailable)?; let query = vec![ ("uploadId".into(), upload_id.into()), ("partNumber".into(), part_number.to_string()), ]; - let exposed = Exposed::new(chunk, pool.clone()); + let exposed = window.expose(); let (response, exposed) = self .exchange( wire::request(Method::PUT, request.path, query, headers), diff --git a/nixl/src/wire.rs b/nixl/src/wire.rs index 0b089d7e..ae11783b 100644 --- a/nixl/src/wire.rs +++ b/nixl/src/wire.rs @@ -7,7 +7,6 @@ use rustfs_nixl::{ NIXL_AGENT_HEADER, NIXL_BUFFER_HEADER, NIXL_METADATA_HEADER, RDMA_BYTES_TRANSFERRED_HEADER, RDMA_REPLY_HEADER, }; -use std::time::{Duration, Instant}; pub(crate) fn request( method: Method, @@ -20,7 +19,6 @@ pub(crate) fn request( path: path.clone(), query, headers, - deadline: Instant::now() + Duration::from_secs(3600), } } diff --git a/nixl/src/wire/native_test.rs b/nixl/src/wire/native_test.rs index 1faa4f8c..acc3c020 100644 --- a/nixl/src/wire/native_test.rs +++ b/nixl/src/wire/native_test.rs @@ -1,10 +1,10 @@ use super::*; -use crate::pool::Pool; +use crate::pool::Pools; use rustfs_nixl::{NixlConfig, NixlServer, RdmaToken}; #[tokio::test] async fn rustfs_reads_and_writes_the_advertised_host_window() { - let client = Pool::open(4096).unwrap(); + let client = Pools::default(); let peer = NixlServer::new(&NixlConfig { agent_name: "rc-interop-peer".into(), chunk_bytes: 4096, @@ -12,17 +12,10 @@ async fn rustfs_reads_and_writes_the_advertised_host_window() { ..Default::default() }) .unwrap(); - let mut source = client.reserve().await.unwrap(); - source.append(b"upload").unwrap(); + let mut source = client.reserve(6).await.unwrap(); + source.chunk.append(b"upload").unwrap(); let mut fields = HeaderMap::new(); - bind( - &mut fields, - &client.name, - &client.metadata, - source.addr(), - 6, - ) - .unwrap(); + source.bind(&mut fields, 6).unwrap(); let token = RdmaToken::from_headers( fields[NIXL_AGENT_HEADER].to_str().unwrap(), Some(fields[NIXL_METADATA_HEADER].to_str().unwrap()), @@ -43,5 +36,5 @@ async fn rustfs_reads_and_writes_the_advertised_host_window() { .await .unwrap(); assert_eq!(written, 6); - assert_eq!(source.staged().unwrap(), b"result"); + assert_eq!(source.chunk.staged().unwrap(), b"result"); } From 17c6d2c3e7e0284b006f4218ed0f0112a9bd2511 Mon Sep 17 00:00:00 2001 From: GatewayJ <835269233@qq.com> Date: Fri, 20 Nov 2026 20:11:45 +0800 Subject: [PATCH 4/5] test(phase-3): verify pool retirement and install native CI dependencies --- .github/workflows/nixl.yml | 5 ++++- nixl/src/pool.rs | 43 +++++++++++++++++++++++--------------- 2 files changed, 30 insertions(+), 18 deletions(-) diff --git a/.github/workflows/nixl.yml b/.github/workflows/nixl.yml index 59f216fe..0ab3fcf3 100644 --- a/.github/workflows/nixl.yml +++ b/.github/workflows/nixl.yml @@ -35,7 +35,10 @@ jobs: run: | echo "NIXL_PREFIX=$RUNNER_TEMP/nixl" >> "$GITHUB_ENV" sudo apt-get update - sudo apt-get install -y --no-install-recommends libclang-dev ninja-build meson + sudo apt-get install -y --no-install-recommends libclang-dev ninja-build python3-dev python3-venv + python3 -m venv "$RUNNER_TEMP/native-tools" + "$RUNNER_TEMP/native-tools/bin/pip" install meson==1.12.1 pybind11==3.1.0 + echo "$RUNNER_TEMP/native-tools/bin" >> "$GITHUB_PATH" - name: Cache the UCX and NIXL runtime id: native-cache uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6 diff --git a/nixl/src/pool.rs b/nixl/src/pool.rs index dfa87260..e5d0ba01 100644 --- a/nixl/src/pool.rs +++ b/nixl/src/pool.rs @@ -47,13 +47,8 @@ impl Pools { pool } }; - let mut lost = pool.lost.subscribe(); - tokio::select! { - biased; - _ = lost.wait_for(|count| *count == WINDOWS_PER_POOL) => continue, - result = pool.agent.reserve(Duration::from_secs(60)) => { - return Ok(Window { chunk: result.map_err(native_error)?, pool }); - } + if let Some(window) = pool.reserve().await? { + return Ok(window); } } } @@ -94,6 +89,18 @@ impl Pool { _budget: budget, })) } + + /// A retired registration wakes its waiters so the owner can replace it. + async fn reserve(self: &Arc) -> Result> { + let mut lost = self.lost.subscribe(); + tokio::select! { + biased; + _ = lost.wait_for(|count| *count == WINDOWS_PER_POOL) => Ok(None), + result = self.agent.reserve(Duration::from_secs(60)) => { + Ok(Some(Window { chunk: result.map_err(native_error)?, pool: self.clone() })) + } + } + } } pub(crate) fn native_error(error: rustfs_nixl::NixlError) -> Error { @@ -154,19 +161,21 @@ mod tests { let second = pools.reserve(32).await.unwrap(); let old = first.pool.clone(); assert!(Arc::ptr_eq(&old, &second.pool)); - let waiting = pools.reserve(32); + let waiting = old.reserve(); tokio::pin!(waiting); - assert!( - tokio::time::timeout(Duration::from_millis(5), &mut waiting) - .await - .is_err() - ); + tokio::select! { + biased; + _ = &mut waiting => panic!("both windows are checked out"), + _ = std::future::ready(()) => {} + } drop(first.expose()); drop(second.expose()); - let replacement = tokio::time::timeout(Duration::from_secs(10), waiting) - .await - .unwrap() - .unwrap(); + tokio::select! { + biased; + result = waiting => assert!(result.unwrap().is_none()), + _ = std::future::ready(()) => panic!("retiring a pool must wake its waiters immediately"), + } + let replacement = pools.reserve(32).await.unwrap(); assert!(!Arc::ptr_eq(&old, &replacement.pool)); let returned = replacement.expose().finished(); drop(returned); From 25584db509d865ce247688032ceea37e644535b6 Mon Sep 17 00:00:00 2001 From: GatewayJ <835269233@qq.com> Date: Fri, 20 Nov 2026 20:48:37 +0800 Subject: [PATCH 5/5] fix(phase-3): preserve S3 version errors and pipeline native uploads --- crates/s3/src/client.rs | 196 +++++++++++--------------- crates/s3/src/client/object_error.rs | 139 ++++++++++++++++++ crates/s3/src/client/staged_upload.rs | 35 +++-- docs/rdma-build.md | 3 +- nixl/src/transport/download.rs | 44 +++--- nixl/src/transport/tests.rs | 43 ++++++ nixl/src/transport/upload.rs | 2 +- nixl/src/wire.rs | 13 -- 8 files changed, 316 insertions(+), 159 deletions(-) create mode 100644 crates/s3/src/client/object_error.rs diff --git a/crates/s3/src/client.rs b/crates/s3/src/client.rs index a4cbb53f..61d6264d 100644 --- a/crates/s3/src/client.rs +++ b/crates/s3/src/client.rs @@ -2,6 +2,7 @@ //! //! Wraps aws-sdk-s3 and implements the ObjectStore trait from rc-core. +mod object_error; mod staged_upload; use async_trait::async_trait; @@ -2932,123 +2933,6 @@ impl S3Client { } } - fn map_object_request_error( - error: &aws_sdk_s3::error::SdkError, - path: &RemotePath, - requested_version: Option<&str>, - ) -> Error - where - E: ProvideErrorMetadata + std::fmt::Display, - { - if let Some(error) = crate::auth::sdk_temporary_credential_error(error) { - return error; - } - let formatted = Self::format_sdk_error(error); - - if let aws_sdk_s3::error::SdkError::ServiceError(service_error) = error { - let raw = service_error.raw(); - let code = service_error.err().code().or_else(|| { - raw.headers() - .get("x-amz-error-code") - .and_then(|value| std::str::from_utf8(value.as_bytes()).ok()) - }); - let status = raw.status().as_u16(); - if matches!(code, Some("InvalidStorageClass")) { - return Error::UnsupportedFeature( - "The S3 endpoint rejected the requested storage class".to_string(), - ); - } - if matches!(code, Some("BadDigest") | Some("InvalidDigest")) { - return Error::Conflict( - "The S3 endpoint rejected the supplied object checksum".to_string(), - ); - } - if matches!(status, 409 | 412) - || matches!( - code, - Some("ConditionalRequestConflict") | Some("PreconditionFailed") - ) - { - return Error::Conflict(formatted); - } - if status == 401 || matches!(code, Some("Unauthorized")) { - return Error::Auth(formatted); - } - - let version_header = raw - .headers() - .get("x-amz-version-id") - .and_then(|value| std::str::from_utf8(value.as_bytes()).ok()); - let is_delete_marker = raw - .headers() - .get("x-amz-delete-marker") - .and_then(|value| std::str::from_utf8(value.as_bytes()).ok()) - .is_some_and(|value| value.eq_ignore_ascii_case("true")); - - let service_message = service_error.err().message().unwrap_or(formatted.as_str()); - if Self::is_retention_denial(service_message) { - return Error::GovernanceDenied { - path: path.to_string(), - version_id: requested_version.map(ToString::to_string), - }; - } - - if matches!(code, Some("AccessDenied") | Some("Forbidden")) || status == 403 { - return Error::Auth(formatted); - } - - if is_delete_marker { - return Error::DeleteMarker { - path: path.to_string(), - version_id: version_header - .or(requested_version) - .unwrap_or("unknown") - .to_string(), - }; - } - - if matches!(code, Some("NoSuchVersion")) - || (requested_version.is_some() - && (matches!(code, Some("NoSuchKey") | Some("NotFound")) || status == 404)) - { - return Error::VersionNotFound { - path: path.to_string(), - version_id: requested_version.unwrap_or("unknown").to_string(), - }; - } - - if matches!(code, Some("NoSuchKey") | Some("NotFound")) || status == 404 { - return Error::NotFound(path.to_string()); - } - } - - if Self::is_retention_denial(&formatted) { - return Error::GovernanceDenied { - path: path.to_string(), - version_id: requested_version.map(ToString::to_string), - }; - } - if formatted.contains("AccessDenied") - || formatted.contains("Forbidden") - || formatted.contains("Unauthorized") - { - return Error::Auth(formatted); - } - if formatted.contains("NoSuchVersion") - || (requested_version.is_some() - && (formatted.contains("NoSuchKey") || formatted.contains("NotFound"))) - { - return Error::VersionNotFound { - path: path.to_string(), - version_id: requested_version.unwrap_or("unknown").to_string(), - }; - } - if formatted.contains("NoSuchKey") || formatted.contains("NotFound") { - return Error::NotFound(path.to_string()); - } - Error::Network(formatted) - } - fn map_object_lock_write_error( error: &aws_sdk_s3::error::SdkError, destination: &RemotePath, @@ -14743,6 +14627,7 @@ mod tests { } enum ExternalBehavior { + OutOfOrderFile(tokio::sync::Notify), Reject, RewriteThenReject(std::path::PathBuf, &'static [u8]), PartialReject, @@ -14758,6 +14643,10 @@ mod tests { #[async_trait] impl ObjectDataTransport for TestExternalTransport { + fn staged_upload(&self) -> Option<&dyn data_transport::StagedUploadTransport> { + matches!(self.behavior, ExternalBehavior::OutOfOrderFile(_)).then_some(self) + } + async fn download( &self, request: DownloadRequest<'_>, @@ -14859,6 +14748,79 @@ mod tests { } } + #[async_trait] + impl data_transport::StagedUploadTransport for TestExternalTransport { + fn max_part_size(&self) -> u64 { + crate::multipart::DEFAULT_PART_SIZE + } + + async fn probe( + &self, + _: &RemotePath, + _: &str, + _: u64, + ) -> data_transport::DataTransportResult { + panic!("forced native upload does not probe") + } + + async fn upload_file_part( + &self, + request: UploadRequest<'_>, + _: Arc, + offset: u64, + ) -> data_transport::DataTransportResult { + let ExternalBehavior::OutOfOrderFile(release_first) = &self.behavior else { + unreachable!() + }; + let UploadOperation::UploadPart { part_number, .. } = request.operation else { + unreachable!() + }; + assert_eq!(offset, (part_number as u64 - 1) * self.max_part_size()); + match part_number { + 1 => release_first.notified().await, + 2 => {} + 3 => release_first.notify_one(), + _ => unreachable!(), + } + let mut object = ObjectInfo::file(&request.path.key, request.content_length as i64); + object.etag = Some(format!("part-{part_number}")); + Ok(UploadResult { + object, + checksum_sha256: None, + }) + } + } + + #[tokio::test] + async fn native_file_upload_refills_free_windows_and_completes_in_part_order() { + let (client, replay) = test_s3_client_with_response_sequence(vec![ + multipart_copy_create_response("native-upload"), + multipart_copy_complete_response(), + ]); + let provider = + external_transport(ExternalBehavior::OutOfOrderFile(tokio::sync::Notify::new())); + let client = client.with_object_data_transport(rc_core::DataTransportMode::Rdma, provider); + let file = tempfile::NamedTempFile::new().unwrap(); + let len = 2 * crate::multipart::DEFAULT_PART_SIZE + 1; + file.as_file().set_len(len).unwrap(); + let path = RemotePath::new("test", "bucket", "data"); + let options = ObjectWriteOptions::default(); + let upload = client.put_object_from_path_with_options(&path, file.path(), &options, |_| {}); + let object = tokio::time::timeout(Duration::from_secs(5), upload) + .await + .expect("part 3 must start while part 1 is pending") + .unwrap(); + assert_eq!(object.size_bytes, Some(len as i64)); + let requests: Vec<_> = replay.actual_requests().collect(); + assert_eq!(requests.len(), 2); + let manifest = std::str::from_utf8(requests[1].body().bytes().unwrap()).unwrap(); + let positions = ["part-1", "part-2", "part-3"].map(|etag| manifest.find(etag).unwrap()); + assert!( + positions[0] < positions[1] && positions[1] < positions[2], + "{manifest}" + ); + } + fn external_transport(behavior: ExternalBehavior) -> Arc { Arc::new(TestExternalTransport { behavior, diff --git a/crates/s3/src/client/object_error.rs b/crates/s3/src/client/object_error.rs new file mode 100644 index 00000000..c17cd1f6 --- /dev/null +++ b/crates/s3/src/client/object_error.rs @@ -0,0 +1,139 @@ +//! S3 object errors shared by SDK operations and signed control requests. + +use super::{ControlResponse, Error, ProvideErrorMetadata, RemotePath, S3Client, SdkError}; + +struct ObjectErrorFields<'a> { + status: u16, + code: Option<&'a str>, + version_id: Option<&'a str>, + delete_marker: bool, +} + +impl<'a> ObjectErrorFields<'a> { + fn from_headers(status: u16, header: impl Fn(&'static str) -> Option<&'a str>) -> Self { + Self { + status, + code: header("x-amz-error-code"), + version_id: header("x-amz-version-id"), + delete_marker: header("x-amz-delete-marker") + .is_some_and(|v| v.eq_ignore_ascii_case("true")), + } + } + + fn classify( + &self, + path: &RemotePath, + requested_version: Option<&str>, + service_message: Option<&str>, + diagnostic: &str, + ) -> Option { + if let Some(error) = crate::auth::temporary_credential_error(self.code) { + return Some(error); + } + let missing = matches!(self.code, Some("NoSuchKey" | "NotFound")) || self.status == 404; + Some(match (self.status, self.code) { + (_, Some("InvalidStorageClass")) => Error::UnsupportedFeature( + "The S3 endpoint rejected the requested storage class".into(), + ), + (_, Some("BadDigest" | "InvalidDigest")) => { + Error::Conflict("The S3 endpoint rejected the supplied object checksum".into()) + } + (409 | 412, _) | (_, Some("ConditionalRequestConflict" | "PreconditionFailed")) => { + Error::Conflict(diagnostic.into()) + } + (401, _) | (_, Some("Unauthorized")) => Error::Auth(diagnostic.into()), + _ if service_message.is_some_and(S3Client::is_retention_denial) => { + Error::GovernanceDenied { + path: path.to_string(), + version_id: requested_version.map(str::to_owned), + } + } + (403, _) | (_, Some("AccessDenied" | "Forbidden")) => Error::Auth(diagnostic.into()), + _ if self.delete_marker => Error::DeleteMarker { + path: path.to_string(), + version_id: self + .version_id + .or(requested_version) + .unwrap_or("unknown") + .into(), + }, + (_, Some("NoSuchVersion")) => Error::VersionNotFound { + path: path.to_string(), + version_id: requested_version.unwrap_or("unknown").into(), + }, + _ if missing => match requested_version { + Some(version) => Error::VersionNotFound { + path: path.to_string(), + version_id: version.into(), + }, + None => Error::NotFound(path.to_string()), + }, + _ => return None, + }) + } +} + +impl ControlResponse { + /// Classify an unsuccessful S3 control response using the caller's version selector. + pub fn object_error(&self, path: &RemotePath, requested_version: Option<&str>) -> Error { + let fields = ObjectErrorFields::from_headers(self.status.as_u16(), |name| { + self.headers.get(name)?.to_str().ok() + }); + let diagnostic = format!("S3 returned HTTP {} for {path}", self.status); + fields + .classify(path, requested_version, None, &diagnostic) + .unwrap_or(Error::General(diagnostic)) + } +} + +impl S3Client { + pub(super) fn map_object_request_error( + error: &aws_sdk_s3::error::SdkError, + path: &RemotePath, + requested_version: Option<&str>, + ) -> Error + where + E: ProvideErrorMetadata + std::fmt::Display, + { + let formatted = Self::format_sdk_error(error); + if let SdkError::ServiceError(service_error) = error { + let raw = service_error.raw(); + let mut response = ObjectErrorFields::from_headers(raw.status().as_u16(), |name| { + raw.headers().get(name) + }); + response.code = service_error.err().code().or(response.code); + let message = service_error.err().message().unwrap_or(&formatted); + if let Some(error) = + response.classify(path, requested_version, Some(message), &formatted) + { + return error; + } + } + + if Self::is_retention_denial(&formatted) { + return Error::GovernanceDenied { + path: path.to_string(), + version_id: requested_version.map(ToString::to_string), + }; + } + if formatted.contains("AccessDenied") + || formatted.contains("Forbidden") + || formatted.contains("Unauthorized") + { + return Error::Auth(formatted); + } + if formatted.contains("NoSuchVersion") + || (requested_version.is_some() + && (formatted.contains("NoSuchKey") || formatted.contains("NotFound"))) + { + return Error::VersionNotFound { + path: path.to_string(), + version_id: requested_version.unwrap_or("unknown").to_string(), + }; + } + if formatted.contains("NoSuchKey") || formatted.contains("NotFound") { + return Error::NotFound(path.to_string()); + } + Error::Network(formatted) + } +} diff --git a/crates/s3/src/client/staged_upload.rs b/crates/s3/src/client/staged_upload.rs index 5959b3f5..f7edcf37 100644 --- a/crates/s3/src/client/staged_upload.rs +++ b/crates/s3/src/client/staged_upload.rs @@ -3,6 +3,7 @@ use super::*; use crate::data_transport::StagedUploadTransport; use aws_sdk_s3::types::{CompletedMultipartUpload, CompletedPart}; +use futures::{StreamExt, stream::FuturesUnordered}; pub(super) enum Source<'a> { File(Arc), @@ -240,20 +241,32 @@ impl S3Client { }; match source { Source::File(file) => { - // Ordered collection preserves the completion manifest while two - // independent positional reads and transfers can run concurrently. - let send = |i: u64| { - staged.upload_file_part(part_request(i), Arc::clone(&file), i * part_size) + const FILE_WINDOWS: usize = 2; + let send = |i| { + let part = staged.upload_file_part( + part_request(i), + Arc::clone(&file), + i * part_size, + ); + async move { (i, part.await) } }; - for i in (0..count).step_by(2) { - if i + 1 == count { - finish_part(i, send(i).await?)?; - } else { - let (first, second) = tokio::join!(send(i), send(i + 1)); - finish_part(i, first?)?; - finish_part(i + 1, second?)?; + let mut remaining = 0..count; + let mut in_flight: FuturesUnordered<_> = + remaining.by_ref().take(FILE_WINDOWS).map(send).collect(); + while let Some((i, result)) = in_flight.next().await { + if let Err(error) = result + .map_err(Error::from) + .and_then(|part| finish_part(i, part)) + { + // Let already-exposed windows receive their receipts before aborting. + while in_flight.next().await.is_some() {} + return Err(error); + } + if let Some(next) = remaining.next() { + in_flight.push(send(next)); } } + parts.sort_unstable_by_key(CompletedPart::part_number); if file.metadata()?.len() != length { return Err(Error::Conflict("Upload source length changed".into())); } diff --git a/docs/rdma-build.md b/docs/rdma-build.md index 7eba4c1f..c5dc1875 100644 --- a/docs/rdma-build.md +++ b/docs/rdma-build.md @@ -28,7 +28,8 @@ or `rdma` to reuse the selection across commands. The default is `http`. Signed read timeouts, including the wait for each transfer receipt. File uploads use positional reads directly into two reusable registered -windows. For transfers of up to 1 MiB, the client can register two 1 MiB +windows. Each completed part frees a window for the next part, and S3 receives +the completion list in part-number order. For transfers of up to 1 MiB, the client can register two 1 MiB windows. Larger transfers use 64 MiB windows, which also serve subsequent small requests on the same client. File downloads write directly into the temporary destination file. A range GET for the next window can proceed while the diff --git a/nixl/src/transport/download.rs b/nixl/src/transport/download.rs index aa76259b..abb1d545 100644 --- a/nixl/src/transport/download.rs +++ b/nixl/src/transport/download.rs @@ -7,10 +7,23 @@ pub(super) enum Sink<'a> { struct Selection<'a> { path: &'a RemotePath, - query: Vec<(String, String)>, + requested_version: Option<&'a str>, total: u64, etag: HeaderValue, - version: Option<&'a str>, + observed_version: Option<&'a str>, +} + +fn read_request( + method: Method, + path: &RemotePath, + version: Option<&str>, + headers: HeaderMap, +) -> ControlRequest { + let query = version + .map(|value| ("versionId".into(), value.to_owned())) + .into_iter() + .collect(); + wire::request(method, path, query, headers) } impl Transport { @@ -39,17 +52,19 @@ impl Transport { let exposed = window.expose(); let (response, exposed) = self .exchange( - wire::request( + read_request( Method::GET, selection.path, - selection.query.clone(), + selection.requested_version, headers, ), exposed, ) .await?; if !response.status.is_success() { - return Err(rejected(wire::s3_error(response.status, selection.path))); + return Err(rejected( + response.object_error(selection.path, selection.requested_version), + )); } if !response.headers.contains_key(RDMA_REPLY_HEADER) { // An ordinary successful GET returned the object in its HTTP body. @@ -75,7 +90,7 @@ impl Transport { ))); } if wire::field(&response.headers, "x-amz-version-id").map_err(rejected)? - != selection.version + != selection.observed_version { return Err(rejected(Error::Conflict(format!( "Object version changed: {}", @@ -114,26 +129,23 @@ impl Transport { "NIXL does not encrypt SSE-C payloads in transit".into(), ))); } - let mut query = Vec::new(); - if let Some(version) = &request.options.version_id { - query.push(("versionId".into(), version.clone())); - } + let requested_version = request.options.version_id.as_deref(); let mut headers = HeaderMap::new(); if request.options.checksum_mode { headers.insert("x-amz-checksum-mode", HeaderValue::from_static("ENABLED")); } let head = self .control - .execute_headers(wire::request( + .execute_headers(read_request( Method::HEAD, request.path, - query.clone(), + requested_version, headers, )) .await .map_err(unavailable)?; if head.status != StatusCode::OK { - return Err(rejected(wire::s3_error(head.status, request.path))); + return Err(rejected(head.object_error(request.path, requested_version))); } let total = wire::field(&head.headers, "content-length") .map_err(rejected)? @@ -145,7 +157,7 @@ impl Transport { "NIXL object exceeds the receive bound".into(), ))); } - let version = wire::field(&head.headers, "x-amz-version-id").map_err(rejected)?; + let observed_version = wire::field(&head.headers, "x-amz-version-id").map_err(rejected)?; let etag = head .headers .get("etag") @@ -153,10 +165,10 @@ impl Transport { .ok_or_else(|| rejected(Error::General("Object HEAD has no ETag".into())))?; let selection = Selection { path: request.path, - query, + requested_version, total, etag, - version, + observed_version, }; let ranged = length > 0 && (request.max_bytes.is_some() || length > WINDOW as u64); let first = length.min(WINDOW as u64) as usize; diff --git a/nixl/src/transport/tests.rs b/nixl/src/transport/tests.rs index e88bd545..c561f803 100644 --- a/nixl/src/transport/tests.rs +++ b/nixl/src/transport/tests.rs @@ -80,3 +80,46 @@ async fn replacement_with_the_same_etag_is_detected_before_writing() { matches!(result, Err(error) if matches!(error.source.as_deref(), Some(Error::Conflict(_)))) ); } + +#[tokio::test] +async fn a_delete_marker_keeps_its_version_and_exit_code() { + struct DeleteMarker; + #[async_trait] + impl ControlExecutor for DeleteMarker { + async fn execute_headers(&self, request: ControlRequest) -> Result { + assert_eq!(request.method, Method::HEAD); + let mut headers = HeaderMap::new(); + headers.insert("x-amz-delete-marker", HeaderValue::from_static("true")); + headers.insert("x-amz-version-id", HeaderValue::from_static("v2")); + Ok(ControlResponse { + status: StatusCode::METHOD_NOT_ALLOWED, + headers, + }) + } + } + + let transport = Factory.create(Arc::new(DeleteMarker)).unwrap(); + let path = RemotePath::new("test", "bucket", "key"); + let options = rc_core::ObjectReadOptions { + version_id: Some("v2".into()), + }; + let alias = rc_core::Alias::new("test", "https://127.0.0.1:1", "test", "test"); + let client = rc_s3::S3Client::new(alias).await.unwrap(); + for mode in [ + rc_core::DataTransportMode::Auto, + rc_core::DataTransportMode::Rdma, + ] { + let client = client + .clone() + .with_object_data_transport(mode, transport.clone()); + let error = client + .write_object_to_with_options(&path, &options, &mut tokio::io::sink(), None) + .await + .expect_err("a delete marker cannot be read as an object"); + assert_eq!(error.exit_code(), 5, "{mode:?}"); + assert!( + matches!(error, Error::DataTransfer { source: Some(source), .. } + if matches!(*source, Error::DeleteMarker { ref version_id, .. } if version_id == "v2")) + ); + } +} diff --git a/nixl/src/transport/upload.rs b/nixl/src/transport/upload.rs index d4a83296..9bff30d7 100644 --- a/nixl/src/transport/upload.rs +++ b/nixl/src/transport/upload.rs @@ -152,7 +152,7 @@ impl Transport { .await?; if response.status != StatusCode::OK { // RustFS can start reading ahead before it validates the multipart ID. - return Err(rejected(wire::s3_error(response.status, request.path))); + return Err(rejected(response.object_error(request.path, None))); } if !response.headers.contains_key(RDMA_REPLY_HEADER) { drop(exposed.finished()); diff --git a/nixl/src/wire.rs b/nixl/src/wire.rs index ae11783b..c83ae964 100644 --- a/nixl/src/wire.rs +++ b/nixl/src/wire.rs @@ -69,19 +69,6 @@ pub(crate) fn receipt(status: StatusCode, headers: &HeaderMap, bytes: u64) -> Re Ok(()) } -pub(crate) fn s3_error(status: StatusCode, path: &RemotePath) -> Error { - match status { - StatusCode::NOT_FOUND => Error::NotFound(path.to_string()), - StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED => { - Error::Auth(format!("S3 refused access to {path}")) - } - StatusCode::PRECONDITION_FAILED | StatusCode::CONFLICT => { - Error::Conflict(format!("Object changed: {path}")) - } - _ => Error::General(format!("S3 returned HTTP {status} for {path}")), - } -} - #[cfg(test)] mod tests { use super::*;