Compare commits

..

2 Commits

Author SHA1 Message Date
唐小鸭 194d4aeef2 fix(sse): drop the SSE-S3 header from SSE-C CopyObject responses
CopyObject to an SSE-C destination answered with
`x-amz-server-side-encryption: AES256` next to the customer-key
headers, for the same reason the multipart responses did: the SSE-C
material records `AES256` as its server-side-encryption value and the
response forwarded it. It now returns only the customer-algorithm and
customer-key-MD5 headers, as PutObject does. Copies to SSE-S3 and
SSE-KMS destinations are unchanged.
2026-11-22 22:38:22 +08:00
唐小鸭 4e680145bd fix(sse): drop the SSE-S3 header from SSE-C multipart responses
CreateMultipartUpload, UploadPart, UploadPartCopy and
CompleteMultipartUpload on an SSE-C upload answered with
`x-amz-server-side-encryption: AES256` next to the customer-key
headers. That header names a managed algorithm, so the response
described an SSE-S3 object.

SSE-C metadata and encryption material record `AES256` as their
server-side-encryption value. PutObject, GetObject and HeadObject
already leave it out of an SSE-C response; the four multipart
projections forwarded it unchanged. They now return only the
customer-algorithm and customer-key-MD5 headers for SSE-C. SSE-S3 and
SSE-KMS multipart responses are unchanged.
2026-11-22 22:33:01 +08:00
9 changed files with 417 additions and 65 deletions
+2
View File
@@ -46,6 +46,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Fixed
- **SSE-C multipart and copy responses no longer carry `x-amz-server-side-encryption`**: `CreateMultipartUpload`, `UploadPart`, `UploadPartCopy` and `CompleteMultipartUpload` on an SSE-C upload, and `CopyObject` to an SSE-C destination, answered with `x-amz-server-side-encryption: AES256` next to the customer-key headers, so a client reading the response saw an SSE-S3 object. They now return only `x-amz-server-side-encryption-customer-algorithm` and `x-amz-server-side-encryption-customer-key-MD5`, as `PutObject`, `GetObject` and `HeadObject` already did. SSE-S3 and SSE-KMS responses are unchanged.
- **Vault KMS backends no longer fail when the server answers reads from a replica**: a Vault or OpenBao node that serves reads locally (an OpenBao standby, a Vault Enterprise performance standby) can return the state from before a write for a short while after acknowledging it. Against such a node the KV2 backend failed every key creation with `404 Key not found` while leaving the key stored without its description and tags, failed operations issued right after a create or update with `Key not found` or `Concurrent modification`, and the Transit backend failed a disable followed quickly by an enable. Key creation on the KV2 backend is now a single create-only write that carries the description and tags. Both backends now re-read a key record when the answer is older than a write the same RustFS node made in the previous five seconds, pause before re-reading after a lost check-and-set write and allow five attempts instead of three, and retry a Transit key delete that is refused because the deletion switch is not visible yet. A different RustFS node reading the same replica can still observe the earlier state until the replica catches up; see [OpenBao as the Vault KMS backend](docs/operations/kms-openbao-compatibility.md).
- **KMS keys could not be described by ARN through the path route**: `GET /rustfs/admin/v3/kms/keys/{key_id}` read the path segment verbatim, so a key id that has to be percent-encoded to fit in one segment — an AWS key ARN, with its `:` and `/` — was looked up, authorized and audited under its encoded spelling and answered `404`. The segment is now percent-decoded first; a segment that is not valid UTF-8 after decoding is refused with `400 InvalidArgument`. The `describe-key?keyId=` form was unaffected.
+311
View File
@@ -789,4 +789,315 @@ mod tests {
assert_eq!(authorizer.calls().len(), 4);
});
}
/// The SSE fields one multipart response carries, each of which becomes a response header.
#[derive(Debug, Default, PartialEq, Eq)]
struct SseResponseFields {
server_side_encryption: Option<String>,
ssekms_key_id: Option<String>,
sse_customer_algorithm: Option<String>,
sse_customer_key_md5: Option<String>,
}
const SSE_HEADER_PREFIX: &str = "x-amz-server-side-encryption";
/// Runs one upload through CreateMultipartUpload, UploadPart, UploadPartCopy and
/// CompleteMultipartUpload and returns the SSE fields of each response, followed by the
/// SSE header names of the encoded completion response.
async fn multipart_sse_responses(
bucket: &str,
key: &str,
requested_sse: Option<&str>,
requested_kms_key_id: Option<&str>,
customer_key: Option<(&str, &str)>,
) -> (Vec<(&'static str, SseResponseFields)>, Vec<String>) {
use crate::app::storage_api::s3::dto::{CompletedPart, CopySource, StreamingBlob, UploadPartInput};
use crate::app::storage_api::test::contract::object::ObjectIO as _;
use rustfs_gateway::{Limits, MetaView, OperationCodec, TargetKind, WireRequest};
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let store = crate::app::gating_test_env::shared_gating_ecstore().await;
let usecase = DefaultMultipartUsecase::from_global();
let source_key = format!("{key}-source");
store
.put_object(
bucket,
&source_key,
&mut crate::storage::PutObjReader::from_vec(b"copied".to_vec()),
&ObjectOptions::default(),
)
.await
.expect("write plaintext copy source");
let customer_algorithm = customer_key.map(|_| "AES256".to_string());
let customer_key_md5 = customer_key.map(|(_, md5)| md5.to_string());
let customer_key = customer_key.map(|(key, _)| key.to_string());
let create = usecase
.execute_create_multipart_upload(
owned_envelope(Method::POST),
CreateMultipartUploadFields {
bucket: bucket.to_string(),
key: key.to_string(),
metadata: None,
tagging: None,
storage_class: None,
server_side_encryption: requested_sse.map(ToOwned::to_owned),
sse_customer_algorithm: customer_algorithm.clone(),
sse_customer_key: customer_key.clone(),
sse_customer_key_md5: customer_key_md5.clone(),
ssekms_key_id: requested_kms_key_id.map(ToOwned::to_owned),
object_lock_legal_hold_status: None,
object_lock_mode: None,
object_lock_retain_until_date: None,
},
None,
)
.await
.expect("create multipart upload");
let upload_id = create.upload_id;
let part = usecase
.execute_upload_part_with_audit(
owned_envelope(Method::PUT),
UploadPartWriteInput::from_legacy(
UploadPartInput {
bucket: bucket.to_string(),
key: key.to_string(),
upload_id: upload_id.clone(),
part_number: 1,
content_length: Some(3),
body: Some(StreamingBlob::from(bytes::Bytes::from_static(b"abc"))),
sse_customer_algorithm: customer_algorithm.clone(),
sse_customer_key: customer_key.clone(),
sse_customer_key_md5: customer_key_md5.clone(),
..Default::default()
},
None,
),
)
.await
.expect("upload part");
let copy = Box::pin(usecase.execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: bucket.to_string(),
key: key.to_string(),
upload_id: upload_id.clone(),
},
part_number: 2,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(CopySource::Bucket {
bucket: bucket.into(),
key: source_key.into(),
version_id: None,
}),
copy_source_range: None,
copy_source_if_match: None,
copy_source_if_none_match: None,
sse_customer_algorithm: customer_algorithm.clone(),
sse_customer_key: customer_key.clone(),
sse_customer_key_md5: customer_key_md5.clone(),
copy_source_sse_customer_algorithm: None,
copy_source_sse_customer_key: None,
copy_source_sse_customer_key_md5: None,
},
))
.await
.expect("copy part");
let mut complete_input = complete_multipart_upload::input_from_s3s(CompleteMultipartUploadInput {
bucket: bucket.to_string(),
key: key.to_string(),
upload_id,
multipart_upload: Some(CompletedMultipartUpload {
parts: Some(vec![CompletedPart {
part_number: Some(1),
..Default::default()
}]),
}),
sse_customer_algorithm: customer_algorithm,
sse_customer_key: customer_key,
sse_customer_key_md5: customer_key_md5,
..Default::default()
})
.map_err(crate::app::dto_values::seam_error)
.expect("owned completion input");
complete_input.multipart_upload.parts[0].e_tag = part
.e_tag
.as_deref()
.map(|tag| rustfs_gateway_types::ETag::from_stored(to_s3s_etag(tag).value().to_owned()));
let complete = Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), complete_input))
.await
.expect("complete multipart upload");
let request = http::Request::builder()
.method("POST")
.uri("http://localhost/bucket/object")
.header("host", "localhost")
.body(bytes::Bytes::new())
.expect("wire request");
let wire = WireRequest::accept(request, &Limits::default()).expect("accepted wire request");
let view = MetaView::of(&wire, TargetKind::Object).expect("object view");
let encoded = rustfs_gateway::dto::CompleteMultipartUpload::encode(complete.clone(), &view, 200)
.expect("completion response encodes");
let mut completion_sse_headers: Vec<String> = encoded
.headers
.keys()
.map(|name| name.as_str().to_owned())
.filter(|name| name.starts_with(SSE_HEADER_PREFIX))
.collect();
completion_sse_headers.sort();
let responses = vec![
(
"CreateMultipartUpload",
SseResponseFields {
server_side_encryption: create.server_side_encryption,
ssekms_key_id: create.ssekms_key_id,
sse_customer_algorithm: create.sse_customer_algorithm,
sse_customer_key_md5: create.sse_customer_key_md5,
},
),
(
"UploadPart",
SseResponseFields {
server_side_encryption: part.server_side_encryption,
ssekms_key_id: part.ssekms_key_id,
sse_customer_algorithm: part.sse_customer_algorithm,
sse_customer_key_md5: part.sse_customer_key_md5,
},
),
(
"UploadPartCopy",
SseResponseFields {
server_side_encryption: copy.server_side_encryption,
ssekms_key_id: copy.ssekms_key_id,
sse_customer_algorithm: copy.sse_customer_algorithm,
sse_customer_key_md5: copy.sse_customer_key_md5,
},
),
(
"CompleteMultipartUpload",
SseResponseFields {
server_side_encryption: complete.server_side_encryption.map(|value| value.as_str().to_owned()),
ssekms_key_id: complete.ssekms_key_id,
sse_customer_algorithm: complete.sse_customer_algorithm,
sse_customer_key_md5: complete.sse_customer_key_md5,
},
),
];
(responses, completion_sse_headers)
}
fn every_multipart_response(expected: impl Fn() -> SseResponseFields) -> Vec<(&'static str, SseResponseFields)> {
[
"CreateMultipartUpload",
"UploadPart",
"UploadPartCopy",
"CompleteMultipartUpload",
]
.into_iter()
.map(|operation| (operation, expected()))
.collect()
}
// `x-amz-server-side-encryption` names the SSE-S3 or SSE-KMS algorithm. An SSE-C upload
// answers with the customer-key headers only, as PutObject, GetObject and HeadObject do.
#[test]
#[serial_test::serial]
fn ssec_multipart_responses_carry_only_the_customer_key_headers() {
crate::app::gating_test_env::run_large_stack_test("mpu-ssec-response-headers", || async {
let (_store, bucket) =
crate::app::gating_test_env::durable_quota_test_bucket("mpu-ssec-response-headers", 16_384).await;
let customer_key = "KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKio=";
let customer_key_md5 = "SaaDheEjzuynJH8eW6AEpQ==";
let (responses, completion_sse_headers) =
multipart_sse_responses(&bucket, "customer-encrypted", None, None, Some((customer_key, customer_key_md5))).await;
assert_eq!(
responses,
every_multipart_response(|| SseResponseFields {
sse_customer_algorithm: Some("AES256".to_string()),
sse_customer_key_md5: Some(customer_key_md5.to_string()),
..Default::default()
})
);
assert_eq!(
completion_sse_headers,
[
"x-amz-server-side-encryption-customer-algorithm",
"x-amz-server-side-encryption-customer-key-md5",
]
);
});
}
#[test]
#[serial_test::serial]
fn managed_sse_multipart_responses_name_the_managed_algorithm() {
crate::app::gating_test_env::run_large_stack_test("mpu-managed-sse-response-headers", || async {
use rustfs_kms::types::{CreateKeyRequest, KeyUsage};
let (_store, bucket) =
crate::app::gating_test_env::durable_quota_test_bucket("mpu-managed-sse-response-headers", 16_384).await;
let key_dir = tempfile::TempDir::new().expect("local KMS key directory");
let manager = crate::app::gating_test_env::shared_gating_ambient().await.kms().handle();
let local_kms = || rustfs_kms::KmsConfig::local(key_dir.path().to_path_buf()).with_insecure_development_defaults();
manager.reconfigure(local_kms()).await.expect("configure local KMS");
let kms_key = manager
.get_encryption_service()
.await
.expect("local KMS encryption service")
.create_key(CreateKeyRequest {
key_name: Some("multipart-response-key".to_string()),
key_usage: KeyUsage::EncryptDecrypt,
description: None,
policy: None,
tags: HashMap::new(),
origin: None,
})
.await
.expect("create multipart KMS key");
// SSE-S3 names no key, so it wraps its data key under the service default.
manager
.reconfigure(local_kms().with_default_key(kms_key.key_id.clone()))
.await
.expect("select the default KMS key");
let (sse_s3, sse_s3_completion_headers) =
multipart_sse_responses(&bucket, "sse-s3-encrypted", Some(ServerSideEncryption::AES256), None, None).await;
assert_eq!(
sse_s3,
every_multipart_response(|| SseResponseFields {
server_side_encryption: Some("AES256".to_string()),
..Default::default()
})
);
assert_eq!(sse_s3_completion_headers, ["x-amz-server-side-encryption"]);
let (sse_kms, sse_kms_completion_headers) = multipart_sse_responses(
&bucket,
"sse-kms-encrypted",
Some(ServerSideEncryption::AWS_KMS),
Some(&kms_key.key_id),
None,
)
.await;
assert_eq!(
sse_kms,
every_multipart_response(|| SseResponseFields {
server_side_encryption: Some("aws:kms".to_string()),
ssekms_key_id: Some(kms_key.key_id.clone()),
..Default::default()
})
);
assert_eq!(
sse_kms_completion_headers,
["x-amz-server-side-encryption", "x-amz-server-side-encryption-aws-kms-key-id"]
);
manager.stop().await.expect("stop local KMS");
});
}
}
+7 -3
View File
@@ -588,8 +588,15 @@ impl DefaultMultipartUsecase {
// Storage has authorized the actual source or committed replay candidate
// before comparing checksums/parts, recovery publication or replay effects.
let encryption_metadata = upload_user_defined.as_ref().unwrap_or(obj_info.user_defined.as_ref());
let ssec_algorithm = encryption_metadata
.get("x-amz-server-side-encryption-customer-algorithm")
.cloned();
// SSE-C metadata also records `x-amz-server-side-encryption: AES256`, but
// that header names a managed algorithm; an SSE-C upload answers with its
// customer-key headers only.
let server_side_encryption = encryption_metadata
.get("x-amz-server-side-encryption")
.filter(|_| ssec_algorithm.is_none())
.map(|s| ServerSideEncryption::custom(s.clone()));
let ssekms_key_id = match server_side_encryption.as_ref() {
Some(sse) if sse.as_str() == ServerSideEncryption::AWS_KMS.as_str() => encryption_metadata
@@ -597,9 +604,6 @@ impl DefaultMultipartUsecase {
.cloned(),
_ => None,
};
let ssec_algorithm = encryption_metadata
.get("x-amz-server-side-encryption-customer-algorithm")
.cloned();
let ssec_key_md5 = encryption_metadata
.get("x-amz-server-side-encryption-customer-key-md5")
.cloned();
+3 -1
View File
@@ -436,7 +436,9 @@ impl DefaultMultipartUsecase {
bucket,
key,
upload_id,
server_side_encryption: effective_sse,
// `x-amz-server-side-encryption` names a managed algorithm; an SSE-C
// upload answers with its customer-key headers only.
server_side_encryption: effective_sse.filter(|_| sse_customer_algorithm.is_none()),
sse_customer_algorithm,
sse_customer_key_md5,
ssekms_key_id: effective_kms_key_id,
@@ -402,7 +402,8 @@ impl DefaultMultipartUsecase {
}
};
write_plan = write_plan.with_encryption(ssec_write);
(Some(ssec_material.server_side_encryption), ssec_material.kms_key_id)
// An SSE-C part answers with its customer-key headers only.
(None, None)
} else if let Some(server_side_encryption) = server_side_encryption {
// Reuse the stored envelope after authorizing this caller against its
// pinned destination key above.
@@ -474,11 +474,8 @@ impl DefaultMultipartUsecase {
}
};
write_plan = write_plan.with_encryption(ssec_write);
(
Some(ssec_material.server_side_encryption),
ssec_material.kms_key_id,
mp_info.user_defined.clone(),
)
// An SSE-C part answers with its customer-key headers only.
(None, None, mp_info.user_defined.clone())
} else if let Some(server_side_encryption) = server_side_encryption {
// Reuse the destination envelope after authorizing this caller against
// its pinned key above. The source read is separately authorized.
+71 -1
View File
@@ -904,7 +904,9 @@ impl DefaultObjectUsecase {
last_modified: oi.mod_time,
copy_source_version_id,
version_id: dest_version,
server_side_encryption: effective_sse,
// `x-amz-server-side-encryption` names a managed algorithm; an SSE-C
// destination answers with its customer-key headers only.
server_side_encryption: effective_sse.filter(|_| sse_customer_algorithm.is_none()),
ssekms_key_id: effective_kms_key_id,
sse_customer_algorithm,
sse_customer_key_md5,
@@ -1483,6 +1485,74 @@ mod tests {
.expect("directory copy test bucket should be removed");
}
// `x-amz-server-side-encryption` names a managed algorithm. A copy to an SSE-C destination
// answers with its customer-key headers only, as PutObject does.
#[tokio::test]
#[serial_test::serial]
async fn copy_object_to_ssec_destination_answers_with_the_customer_key_headers_only() {
use crate::app::storage_api::test::contract::bucket::{BucketOperations as _, DeleteBucketOptions, MakeBucketOptions};
let store = crate::app::gating_test_env::shared_gating_ecstore().await;
if current_app_context().is_none() {
crate::app::runtime_sources::install_test_app_context(Arc::clone(&store)).await;
}
let ambient = current_app_context().expect("SSE-C copy test requires an AppContext");
let context = Arc::new(AppContext::new(Arc::clone(&store), ambient.iam(), ambient.kms()));
let bucket = format!("copy-ssec-response-{}", Uuid::new_v4());
let customer_key_md5 = "SaaDheEjzuynJH8eW6AEpQ==";
store
.make_bucket(&bucket, &MakeBucketOptions::default())
.await
.expect("SSE-C copy test bucket should be created");
store
.put_object(
&bucket,
"source.bin",
&mut PutObjReader::from_vec(b"copy source".to_vec()),
&ObjectOptions::default(),
)
.await
.expect("plaintext copy source should be written");
let mut input = CopyObjectInput::builder()
.copy_source(CopySource::Bucket {
bucket: bucket.clone().into(),
key: "source.bin".into(),
version_id: None,
})
.bucket(bucket.clone())
.key("customer-encrypted.bin".to_string())
.build()
.expect("SSE-C copy input should build");
input.sse_customer_algorithm = Some("AES256".to_string());
input.sse_customer_key = Some("KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKio=".to_string());
input.sse_customer_key_md5 = Some(customer_key_md5.to_string());
let response = copy_owned(&DefaultObjectUsecase::with_context(Some(context)), build_request(input, Method::PUT))
.await
.expect("copying to an SSE-C destination should succeed");
assert_eq!(
(
response.server_side_encryption.as_deref(),
response.ssekms_key_id.as_deref(),
response.sse_customer_algorithm.as_deref(),
response.sse_customer_key_md5.as_deref(),
),
(None, None, Some("AES256"), Some(customer_key_md5))
);
store
.delete_bucket(
&bucket,
&DeleteBucketOptions {
force: true,
..Default::default()
},
)
.await
.expect("SSE-C copy test bucket should be removed");
}
#[tokio::test]
async fn execute_copy_object_allows_self_copy_of_null_version() {
// A "null" source version id is a restore of the null version, not a no-op self-copy.
+2 -12
View File
@@ -543,18 +543,8 @@ async fn ssec_wire_contract(usecase: &DefaultObjectUsecase, server: &crate::embe
.build()
.unwrap();
{
let envelope = crate::app::RequestEnvelope::from_parts(
crate::app::RequestHead {
method: Method::PUT,
uri: http::Uri::from_static("/"),
headers: http::HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
http::Extensions::new(),
);
let input = crate::app::object_usecase::PutObjectWriteInput::from_legacy(input, None);
let (envelope, input) =
crate::app::object_usecase::PutObjectWriteInput::from_test_request(build_request(input, Method::PUT));
crate::app::test_seams::put_object(usecase, envelope, input)
}
.await
+17 -42
View File
@@ -2624,35 +2624,6 @@ mod tests {
.map_err(S3Error::from)
}
/// Method-only envelope. `build_request` leaves the URI as `/`, the headers empty, and the trailing headers absent.
fn method_only_put_envelope() -> crate::app::RequestEnvelope {
crate::app::RequestEnvelope::from_parts(
crate::app::RequestHead {
method: Method::PUT,
uri: http::Uri::from_static("/"),
headers: HeaderMap::new(),
credentials: None,
region: None,
service: None,
},
http::Extensions::new(),
)
}
async fn put_method_only(usecase: &DefaultObjectUsecase, input: PutObjectInput) -> S3Result<PutObjectWriteOutput> {
let input = PutObjectWriteInput::from_legacy(input, None);
Box::pin(usecase.execute_put_object_owned(method_only_put_envelope(), input))
.await
.map_err(S3Error::from)
}
async fn put_extract_method_only(usecase: &DefaultObjectUsecase, input: PutObjectInput) -> S3Result<PutObjectWriteOutput> {
let input = PutObjectWriteInput::from_legacy(input, None);
Box::pin(usecase.execute_put_object_extract_owned(method_only_put_envelope(), input))
.await
.map_err(S3Error::from)
}
#[tokio::test]
#[serial_test::serial]
async fn s3_put_uses_tail_drained_completion_before_acknowledgement() {
@@ -2676,7 +2647,7 @@ mod tests {
let usecase = DefaultObjectUsecase::with_context(Some(context));
let (response, observed) = PUT_STORAGE_TEST_COMPLETION
.scope(std::cell::Cell::new(None), async {
let response = Box::pin(put_method_only(&usecase, input)).await;
let response = Box::pin(put_owned(&usecase, build_request(input, Method::PUT))).await;
(response, PUT_STORAGE_TEST_COMPLETION.with(std::cell::Cell::get))
})
.await;
@@ -2775,7 +2746,7 @@ mod tests {
..Default::default()
};
let error = runtime
.block_on(Box::pin(put_extract_method_only(&usecase, input)))
.block_on(Box::pin(put_extract_owned(&usecase, build_request(input, Method::PUT))))
.expect_err("missing archive body");
assert_eq!(error.code(), &S3ErrorCode::IncompleteBody);
assert_eq!(
@@ -2824,7 +2795,7 @@ mod tests {
// The gateway's dispatch names the operation before the use case runs.
Box::pin(async {
rustfs_io_metrics::record_s3_op(S3Operation::PutObject);
put_method_only(&usecase, input).await
put_owned(&usecase, build_request(input, Method::PUT)).await
}),
));
runtime.block_on(std::future::poll_fn(|cx| {
@@ -3320,7 +3291,7 @@ mod tests {
.build()
.expect("PUT input must build");
let put_usecase = DefaultObjectUsecase::with_context(Some(context));
let put = tokio::spawn(async move { put_method_only(&put_usecase, put_input).await });
let put = tokio::spawn(async move { put_owned(&put_usecase, build_request(put_input, Method::PUT)).await });
tokio::time::timeout(Duration::from_secs(2), async {
while !object_traffic_health.snapshot().write_stalled {
tokio::task::yield_now().await;
@@ -3548,7 +3519,8 @@ mod tests {
.build()
.expect("zero-copy PUT input must build");
let zero_copy_usecase = DefaultObjectUsecase::with_context(Some(context));
let zero_copy_put = tokio::spawn(async move { put_method_only(&zero_copy_usecase, zero_copy_input).await });
let zero_copy_put =
tokio::spawn(async move { put_owned(&zero_copy_usecase, build_request(zero_copy_input, Method::PUT)).await });
tokio::time::timeout(Duration::from_secs(30), async {
while !object_traffic_health.snapshot().write_stalled {
@@ -4624,9 +4596,10 @@ mod tests {
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let usecase = DefaultObjectUsecase::without_context();
let err = Box::pin(put_method_only(&usecase, input)).await.unwrap_err();
let err = Box::pin(put_owned(&usecase, req)).await.unwrap_err();
assert_eq!(err.code(), &S3ErrorCode::InvalidStorageClass);
}
@@ -4848,7 +4821,7 @@ mod tests {
.expect("SSE-C PUT input must build");
let usecase = DefaultObjectUsecase::from_global();
let response = put_method_only(&usecase, input)
let response = put_owned(&usecase, build_request(input, Method::PUT))
.await
.unwrap_or_else(|err| panic!("a {algorithm} default bucket must accept an SSE-C PUT: {err:?}"));
assert_eq!(response.server_side_encryption, None);
@@ -5017,7 +4990,7 @@ mod tests {
.build()
.expect("legacy quota PUT input should build");
let err = put_method_only(&DefaultObjectUsecase::from_global(), input)
let err = put_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
.await
.expect_err("4 GiB used plus a 2 GiB PUT must exceed a 5 GiB legacy quota");
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
@@ -5063,7 +5036,7 @@ mod tests {
.content_length(Some(i64::try_from(payload.len()).expect("test payload length must fit i64")))
.build()
.expect("PUT input should build");
put_method_only(&DefaultObjectUsecase::from_global(), input)
put_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
.await
.expect("a ledger-admitted bucket must accept a write without scanner usage");
@@ -5075,7 +5048,7 @@ mod tests {
.content_length(Some(i64::try_from(too_large.len()).expect("test payload length must fit i64")))
.build()
.expect("PUT input should build");
let err = put_method_only(&DefaultObjectUsecase::from_global(), input)
let err = put_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
.await
.expect_err("the ledger must still reject a write above the quota limit");
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
@@ -5478,7 +5451,7 @@ mod tests {
.expect("PUT input must build");
let usecase = DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
let err = Box::pin(put_method_only(&usecase, input))
let err = Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
.await
.expect_err("an unreadable bucket encryption configuration must refuse the write");
@@ -5523,7 +5496,9 @@ mod tests {
metrics::with_local_recorder(&recorder, || {
request.in_scope(|| {
runtime.block_on(async {
Box::pin(put_method_only(&usecase, input)).await.expect("S3 PUT must commit");
Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
.await
.expect("S3 PUT must commit");
assert_eq!(current_s3_http_operation_name(), Some("s3:PutObject"));
assert_eq!(crate::app::storage_api::diagnostic::current_read_version_entry_source(), None);
})
@@ -5588,7 +5563,7 @@ mod tests {
.expect("PUT input must build");
let usecase = DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
Box::pin(put_method_only(&usecase, input))
Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
.await
.expect("a bucket without default encryption must still accept a plaintext write");