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..0ab3fcf3 --- /dev/null +++ b/.github/workflows/nixl.yml @@ -0,0 +1,56 @@ +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 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 + 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/.gitignore b/.gitignore index f0844ff5..a0b6ddef 100644 --- a/.gitignore +++ b/.gitignore @@ -28,6 +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 746f35c4..af94344a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -exclude = ["rdma", "vendor/rustfs-ucx"] +exclude = ["nixl"] 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/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 d4993fd9..61d6264d 100644 --- a/crates/s3/src/client.rs +++ b/crates/s3/src/client.rs @@ -2,6 +2,9 @@ //! //! Wraps aws-sdk-s3 and implements the ObjectStore trait from rc-core. +mod object_error; +mod staged_upload; + use async_trait::async_trait; use aws_credential_types::Credentials; use aws_sdk_s3::error::{ProvideErrorMetadata, SdkError}; @@ -63,9 +66,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; @@ -250,25 +252,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 @@ -279,9 +262,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 { @@ -1788,7 +1769,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, @@ -1914,7 +1894,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, @@ -1924,10 +1903,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) } @@ -2034,6 +2010,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 +2346,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 '{}': {}", @@ -2872,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, @@ -3824,8 +3768,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(); @@ -3836,10 +3779,7 @@ impl S3Client { method, url, headers, - match payload { - ControlPayload::Body => SignableBody::Bytes(body), - ControlPayload::External { .. } => SignableBody::UnsignedPayload, - }, + body, RequestSigningOptions { region: &self.alias.region, settings, @@ -4534,7 +4474,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 +4504,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 +4664,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 +4847,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 +4866,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 } } @@ -7814,37 +7700,12 @@ 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 { + async fn execute_headers(&self, request: ControlRequest) -> 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( - "The external control operation deadline has elapsed".to_string(), - )); - } - Some(deadline) - } - }; let url = self.external_control_url(&request.path, &request.query)?; let mut headers = request.headers; for name in [ @@ -7882,11 +7743,7 @@ impl ControlExecutor for 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( @@ -7898,75 +7755,33 @@ impl ControlExecutor for 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 + // 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) - .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(Duration::from_millis( + timeout.connect_ms.saturating_add(timeout.read_ms), + )) .send() .await - .map_err(|_| Error::Network("External control exchange failed".to_string()))?; - let status = response.status(); - let headers = response.headers().clone(); - 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); - } + .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, - headers, - body: Bytes::from(body), + status: response.status(), + headers: std::mem::take(response.headers_mut()), }) } } @@ -8137,7 +7952,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, @@ -8197,7 +8011,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, @@ -8330,7 +8143,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(), @@ -14815,6 +14627,7 @@ mod tests { } enum ExternalBehavior { + OutOfOrderFile(tokio::sync::Notify), Reject, RewriteThenReject(std::path::PathBuf, &'static [u8]), PartialReject, @@ -14830,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<'_>, @@ -14931,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, @@ -15600,8 +15490,7 @@ mod tests { &Method::GET, sdk_request.uri(), &headers, - &[], - ControlPayload::Body, + SignableBody::Bytes(&[]), time, ) .await @@ -15630,58 +15519,42 @@ mod tests { path: RemotePath::new("test", "bucket", "key"), query: Vec::new(), headers: HeaderMap::new(), - body: Bytes::new(), - payload: ControlPayload::Body, - response_limit: 1024, - }; - 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); } #[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(), - body: Bytes::new(), - payload: ControlPayload::External { - deadline: Instant::now(), - }, - response_limit: 1024, }; - assert!(matches!( - ControlExecutor::execute(&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] @@ -15698,10 +15571,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/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 new file mode 100644 index 00000000..f7edcf37 --- /dev/null +++ b/crates/s3/src/client/staged_upload.rs @@ -0,0 +1,318 @@ +//! 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}; +use futures::{StreamExt, stream::FuturesUnordered}; + +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) => { + 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) } + }; + 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())); + } + } + 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..2dd3ff59 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,45 +25,25 @@ 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 }, } /// 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; -} - -/// 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(); @@ -167,6 +146,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 +176,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/ADR/0001-object-data-transport.md b/docs/ADR/0001-object-data-transport.md index 3f2f51f5..6f9955ab 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 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. 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 2e131f45..c5dc1875 100644 --- a/docs/rdma-build.md +++ b/docs/rdma-build.md @@ -1,70 +1,58 @@ -# Optional external object data build +# Object data over RDMA -The normal workspace builds without access to the private transport repository: +## RustFS native NIXL/UCX -```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: +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 manifest pins the public RustFS library revision, and its lockfile +pins the corresponding NIXL bindings. ```sh -git submodule update --init vendor/rustfs-ucx ./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 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. +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` +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. 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 +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 +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. 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..e5d0ba01 --- /dev/null +++ b/nixl/src/pool.rs @@ -0,0 +1,184 @@ +//! Registered host memory and ownership while the server can access it. + +use base64::{Engine, engine::general_purpose::STANDARD}; +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::{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()); +const WINDOWS_PER_POOL: usize = 2; + +/// 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 + } + }; + if let Some(window) = pool.reserve().await? { + return Ok(window); + } + } + } +} + +struct Pool { + lost: watch::Sender, + agent: Arc, + name: HeaderValue, + metadata: HeaderValue, + _budget: SemaphorePermit<'static>, +} + +impl Pool { + 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: WINDOWS_PER_POOL * 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, + lost: watch::Sender::new(0), + _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 { + Error::General(format!("NIXL/UCX: {error}")) +} + +pub(crate) struct Window { + pub(crate) chunk: StagingChunk, + pool: Arc, +} + +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 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(window) = self.0.take() { + window.pool.lost.send_modify(|lost| *lost += 1); + QUARANTINE + .lock() + .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 = old.reserve(); + tokio::pin!(waiting); + tokio::select! { + biased; + _ = &mut waiting => panic!("both windows are checked out"), + _ = std::future::ready(()) => {} + } + drop(first.expose()); + drop(second.expose()); + 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); + assert!(old.agent.try_reserve().is_none()); + } +} diff --git a/nixl/src/transport.rs b/nixl/src/transport.rs new file mode 100644 index 00000000..2033f831 --- /dev/null +++ b/nixl/src/transport.rs @@ -0,0 +1,104 @@ +//! 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; +use std::sync::Arc; +use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt}; + +use crate::pool::{Exposed, Pools, WINDOW, Window, native_error}; +use crate::wire; + +pub(crate) struct Factory; + +impl ObjectDataTransportFactory for Factory { + fn create(&self, control: Arc) -> Result> { + Ok(Arc::new(Transport { + control, + pools: Pools::default(), + })) + } +} + +struct Transport { + control: Arc, + pools: Pools, +} + +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_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 + } +} + +#[cfg(test)] +mod tests; diff --git a/nixl/src/transport/download.rs b/nixl/src/transport/download.rs new file mode 100644 index 00000000..abb1d545 --- /dev/null +++ b/nixl/src/transport/download.rs @@ -0,0 +1,235 @@ +use super::*; + +pub(super) enum Sink<'a> { + File(Arc), + Writer(&'a mut (dyn AsyncWrite + Send + Unpin)), +} + +struct Selection<'a> { + path: &'a RemotePath, + requested_version: Option<&'a str>, + total: u64, + etag: HeaderValue, + 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 { + async fn fetch( + &self, + selection: &Selection<'_>, + offset: u64, + len: usize, + ranged: bool, + ) -> DataTransportResult { + 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 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( + read_request( + Method::GET, + selection.path, + selection.requested_version, + headers, + ), + exposed, + ) + .await?; + if !response.status.is_success() { + 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. + // 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 window = 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 wire::field(&response.headers, "x-amz-version-id").map_err(rejected)? + != selection.observed_version + { + return Err(rejected(Error::Conflict(format!( + "Object version changed: {}", + selection.path + )))); + } + 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(), + ))); + } + } + window + .chunk + .advance(len) + .map_err(native_error) + .map_err(rejected)?; + Ok(window) + } + + 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 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(read_request( + Method::HEAD, + request.path, + requested_version, + headers, + )) + .await + .map_err(unavailable)?; + if head.status != StatusCode::OK { + return Err(rejected(head.object_error(request.path, requested_version))); + } + 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(), + ))); + } + let observed_version = wire::field(&head.headers, "x-amz-version-id").map_err(rejected)?; + 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, + requested_version, + total, + etag, + observed_version, + }; + 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.chunk.staged().map_err(native_error)?); + } + let offset = end - current.chunk.len() as u64; + match &mut target { + Sink::Writer(writer) => { + writer + .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.chunk.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/tests.rs b/nixl/src/transport/tests.rs new file mode 100644 index 00000000..c561f803 --- /dev/null +++ b/nixl/src/transport/tests.rs @@ -0,0 +1,125 @@ +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(_)))) + ); +} + +#[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 new file mode 100644 index 00000000..9bff30d7 --- /dev/null +++ b/nixl/src/transport/upload.rs @@ -0,0 +1,174 @@ +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 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)?; + 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, window) + .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 mut window = self + .pools + .reserve(first_part_bytes) + .await + .map_err(unavailable)?; + window + .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, window).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 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, window) + .await? + .ok_or_else(declined_part) + } +} + +impl Transport { + async fn send_part( + &self, + request: &UploadRequest<'_>, + window: Window, + ) -> 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(); + window.bind(&mut headers, len).map_err(unavailable)?; + let query = vec![ + ("uploadId".into(), upload_id.into()), + ("partNumber".into(), part_number.to_string()), + ]; + let exposed = window.expose(); + 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(response.object_error(request.path, None))); + } + 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..c83ae964 --- /dev/null +++ b/nixl/src/wire.rs @@ -0,0 +1,97 @@ +//! 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::ControlRequest; +use rustfs_nixl::{ + NIXL_AGENT_HEADER, NIXL_BUFFER_HEADER, NIXL_METADATA_HEADER, RDMA_BYTES_TRANSFERRED_HEADER, + RDMA_REPLY_HEADER, +}; + +pub(crate) fn request( + method: Method, + path: &RemotePath, + query: Vec<(String, String)>, + headers: HeaderMap, +) -> ControlRequest { + ControlRequest { + method, + path: path.clone(), + query, + headers, + } +} + +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(()) +} + +#[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..acc3c020 --- /dev/null +++ b/nixl/src/wire/native_test.rs @@ -0,0 +1,40 @@ +use super::*; +use crate::pool::Pools; +use rustfs_nixl::{NixlConfig, NixlServer, RdmaToken}; + +#[tokio::test] +async fn rustfs_reads_and_writes_the_advertised_host_window() { + let client = Pools::default(); + 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(6).await.unwrap(); + source.chunk.append(b"upload").unwrap(); + let mut fields = HeaderMap::new(); + 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()), + 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.chunk.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" 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