Compare commits

...

14 Commits

Author SHA1 Message Date
overtrue 9b6d60e934 test(object): own method-only put envelopes
Twelve header-free puts call the owned entry point, and each assertion stays
on the same output and error code.
2026-11-22 23:45:26 +08:00
overtrue bb94ec983b test(object): own the invalid-storage-class put envelope
The storage-class rejection carries no request headers, so it uses the owned
request and still rejects the class before any store call.
2026-11-22 23:41:23 +08:00
overtrue 6a1b92b783 test(object): own the SSE-C put envelope
The boundary put carries no request headers, so it uses the owned request
and still stores the customer-key object.
2026-11-22 23:05:30 +08:00
overtrue 818a6b6a14 test(multipart): own the retry copy envelope
The copy after the UploadPart permit is released carries no request headers,
so it uses the owned request and still checks the copied bytes.
2026-11-22 22:31:32 +08:00
overtrue 67d306b0de test(multipart): own the unconditional create envelope
The second create in the If-None-Match test carries no request headers, so
it uses the owned request and still requires an upload id.
2026-11-22 21:55:59 +08:00
overtrue a6f881b42d test(multipart): own the KMS upload-part envelope 2026-11-22 21:25:04 +08:00
overtrue dba23c4f55 test(multipart): own the KMS create envelope
The versioned KMS upload is created on the owned request, and the upload id
is still required before the encrypted part is written.
2026-11-22 20:54:59 +08:00
overtrue 0d17f5f713 test(multipart): own the KMS completion and replay envelope
The versioned KMS completion uses the same owned mapping on both attempts,
and the listing assertions stay in place.
2026-11-22 20:18:13 +08:00
overtrue e09df1f7cd test(multipart): own the other concurrent completion envelope
The second concurrent completion uses the same owned mapping, and exactly
one of the two commits still succeeds.
2026-11-22 19:45:16 +08:00
overtrue c5c65e112e test(multipart): own one concurrent completion envelope
The first concurrent completion still shares the durable quota, so exactly
one of the two commits.
2026-11-22 19:14:04 +08:00
overtrue dfa3d7a2cd test(multipart): own the If-Match completion refusal
A weak or nonmatching If-Match still fails as PreconditionFailed before the
existing object is overwritten.
2026-11-22 18:43:06 +08:00
overtrue 578025149b test(multipart): own the weak If-None-Match completion refusal
A weak If-None-Match ETag on complete is still rejected as unsupported.
2026-11-22 18:10:07 +08:00
overtrue bfc51cf3da test(multipart): own the DTO-only If-None-Match completion refusal
A DTO-only If-None-Match star still fails before the existing object is overwritten.
2026-11-22 17:38:36 +08:00
overtrue 78b35c3ea8 test(multipart): own the SSE-C completion checksum envelope
Keyless completion still fails before the plaintext checksum is disclosed, and a verified key still completes and replays.
2026-11-22 17:07:38 +08:00
4 changed files with 478 additions and 80 deletions
+394 -51
View File
@@ -1357,7 +1357,58 @@ mod tests {
part.e_tag = Some(ETag::Strong("guessed-etag".to_string()));
part.checksum_sha256 = Some("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=".to_string());
}
let result = usecase.complete_for_s3s_request(build_request(input, Method::POST)).await;
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let mut s3s_input = input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let result = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => Err(crate::app::dto_values::seam_error(error)),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(usecase.execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
}
}
};
if keyed {
let response = result.expect("verified key completes and replays");
assert!(response.checksum_sha256.is_some(), "verified key retains checksum response");
@@ -1563,36 +1614,36 @@ mod tests {
.await
.expect("configure bucket-default SSE-KMS");
let usecase = DefaultMultipartUsecase::from_global();
let upload_id = usecase
.execute_create_multipart_upload_from_s3s(build_request(
CreateMultipartUploadInput {
let created = usecase
.execute_create_multipart_upload(
owned_envelope(Method::POST),
super::super::CreateMultipartUploadFields::from_legacy(CreateMultipartUploadInput {
bucket: bucket.clone(),
key: key.to_string(),
..Default::default()
},
Method::POST,
))
}),
None,
)
.await
.expect("create KMS multipart upload")
.output
.upload_id
.expect("KMS upload id");
let part = usecase
.execute_upload_part(build_request(
UploadPartInput {
bucket: bucket.clone(),
key: key.to_string(),
upload_id: upload_id.clone(),
part_number: 1,
content_length: Some(3),
body: Some(StreamingBlob::from(Bytes::from_static(b"abc"))),
..Default::default()
},
Method::PUT,
))
.expect("create KMS multipart upload");
let upload_id = created.upload_id;
assert!(!upload_id.is_empty(), "KMS upload id");
let input = UploadPartInput {
bucket: bucket.clone(),
key: key.to_string(),
upload_id: upload_id.clone(),
part_number: 1,
content_length: Some(3),
body: Some(StreamingBlob::from(Bytes::from_static(b"abc"))),
..Default::default()
};
let output = usecase
.execute_upload_part_with_audit(
owned_envelope(Method::PUT),
super::super::UploadPartWriteInput::from_legacy(input, None),
)
.await
.expect("upload encrypted KMS part")
.output;
.expect("upload encrypted KMS part");
let complete = CompleteMultipartUploadInput {
bucket: bucket.clone(),
key: key.to_string(),
@@ -1600,17 +1651,68 @@ mod tests {
multipart_upload: Some(CompletedMultipartUpload {
parts: Some(vec![CompletedPart {
part_number: Some(1),
e_tag: part.e_tag,
e_tag: output
.e_tag
.map(|tag| crate::app::storage_api::test::object_utils::to_s3s_etag(&tag)),
..Default::default()
}]),
}),
..Default::default()
};
for _ in 0..2 {
let response = usecase
.complete_for_s3s_request(build_request(complete.clone(), Method::POST))
.await
.expect("complete and replay KMS multipart upload");
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let mut s3s_input = complete.clone();
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let response = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => Err(crate::app::dto_values::seam_error(error)),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(usecase.execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
}
}
}
.expect("complete and replay KMS multipart upload");
let etag = etag_to_s3s(&response.e_tag.expect("KMS completed ETag"));
let version_id = response.version_id.expect("KMS completed version");
assert_ne!(version_id, "null");
@@ -1720,13 +1822,16 @@ mod tests {
.expect_err("create multipart upload with If-None-Match: * on existing key must fail");
assert_eq!(create_err.code(), &crate::app::storage_api::s3::S3ErrorCode::PreconditionFailed);
let second_upload_id = usecase
.execute_create_multipart_upload_from_s3s(build_request(create_input, Method::POST))
let second_created = usecase
.execute_create_multipart_upload(
owned_envelope(Method::POST),
super::super::CreateMultipartUploadFields::from_legacy(create_input),
None,
)
.await
.expect("unconditional create multipart upload should succeed")
.output
.upload_id
.expect("second create response should contain upload id");
.expect("unconditional create multipart upload should succeed");
let second_upload_id = second_created.upload_id;
assert!(!second_upload_id.is_empty(), "second create response should contain upload id");
let mut second_reader = PutObjReader::from_vec(b"replacement multipart body".to_vec());
let second_part = store
.put_object_part(&bucket, object, &second_upload_id, 1, &mut second_reader, &ObjectOptions::default())
@@ -1749,10 +1854,54 @@ mod tests {
.multipart_upload(Some(completed_parts.clone()))
.build()
.expect("DTO-only complete multipart input should build");
let dto_complete_err = usecase
.complete_for_s3s_request(build_request(dto_only_complete_input, Method::POST))
.await
.expect_err("DTO-only If-None-Match: * on existing key must fail");
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let mut s3s_input = dto_only_complete_input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let rejected = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => Err(crate::app::dto_values::seam_error(error)),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(usecase.execute_complete_multipart_upload_parts(owned_envelope(Method::POST), owned, None)).await
}
}
}
};
let dto_complete_err = rejected.expect_err("DTO-only If-None-Match: * on existing key must fail");
assert_eq!(dto_complete_err.code(), &S3ErrorCode::PreconditionFailed);
for condition in [ETag::Weak(committed_etag.clone()), ETag::Strong("different-etag".to_string())] {
@@ -1764,10 +1913,53 @@ mod tests {
.multipart_upload(Some(completed_parts.clone()))
.build()
.expect("If-Match complete input should build");
let err = usecase
.complete_for_s3s_request(build_request(input, Method::POST))
.await
.expect_err("weak or nonmatching If-Match must reject the overwrite");
let mut s3s_input = input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let rejected = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => Err(crate::app::dto_values::seam_error(error)),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(usecase.execute_complete_multipart_upload_parts(owned_envelope(Method::POST), owned, None))
.await
}
}
}
};
let err = rejected.expect_err("weak or nonmatching If-Match must reject the overwrite");
assert_eq!(err.code(), &S3ErrorCode::PreconditionFailed);
}
@@ -1782,10 +1974,52 @@ mod tests {
.multipart_upload(Some(completed_parts.clone()))
.build()
.expect("weak If-None-Match complete multipart input should build");
let weak_complete_err = usecase
.complete_for_s3s_request(build_request(weak_if_none_match_input, Method::POST))
.await
.expect_err("weak If-None-Match ETag must be rejected as unsupported");
let mut s3s_input = weak_if_none_match_input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
let rejected = match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => Err(crate::app::dto_values::seam_error(error)),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(usecase.execute_complete_multipart_upload_parts(owned_envelope(Method::POST), owned, None)).await
}
}
}
};
let weak_complete_err = rejected.expect_err("weak If-None-Match ETag must be rejected as unsupported");
assert_eq!(weak_complete_err.code(), &S3ErrorCode::NotImplemented);
let second_complete_input = CompleteMultipartUploadInput::builder()
@@ -2022,8 +2256,117 @@ mod tests {
}
let first_usecase = usecase.clone();
let first = first_usecase.complete_for_s3s_request(build_request(inputs.remove(0), Method::POST));
let second = usecase.complete_for_s3s_request(build_request(inputs.remove(0), Method::POST));
let first_input = inputs.remove(0);
let first = async move {
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let mut s3s_input = first_input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => Err(crate::app::dto_values::seam_error(error)),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(first_usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(first_usecase.execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
}
}
}
};
let second_usecase = usecase;
let second_input = inputs.remove(0);
let second = async move {
use rustfs_gateway_types::compat::s3s_5761ddfe::generated::ops::complete_multipart_upload;
let mut s3s_input = second_input;
let has_upload = s3s_input.multipart_upload.is_some();
s3s_input.multipart_upload.get_or_insert_with(Default::default);
let tags: Vec<Option<String>> = s3s_input
.multipart_upload
.iter_mut()
.flat_map(|upload| upload.parts.iter_mut().flatten())
.map(|part| {
part.part_number.get_or_insert(0);
part.e_tag.take().map(|tag| tag.value().to_owned())
})
.collect();
for checksum in [
&mut s3s_input.checksum_crc32,
&mut s3s_input.checksum_crc32c,
&mut s3s_input.checksum_crc64nvme,
&mut s3s_input.checksum_md5,
&mut s3s_input.checksum_sha1,
&mut s3s_input.checksum_sha256,
&mut s3s_input.checksum_sha512,
&mut s3s_input.checksum_xxhash128,
&mut s3s_input.checksum_xxhash3,
&mut s3s_input.checksum_xxhash64,
] {
*checksum = None;
}
match complete_multipart_upload::input_from_s3s(s3s_input) {
Err(error) => Err(crate::app::dto_values::seam_error(error)),
Ok(mut owned) => {
for (part, tag) in owned.multipart_upload.parts.iter_mut().zip(tags) {
part.e_tag = tag.map(rustfs_gateway_types::ETag::from_stored);
}
let taken = std::mem::take(&mut owned.multipart_upload);
let parts = has_upload.then_some(taken);
match parts {
Some(parts) => {
owned.multipart_upload = parts;
Box::pin(second_usecase.execute_complete_multipart_upload(owned_envelope(Method::POST), owned)).await
}
None => {
Box::pin(second_usecase.execute_complete_multipart_upload_parts(
owned_envelope(Method::POST),
owned,
None,
))
.await
}
}
}
}
};
let (first, second) = tokio::join!(first, second);
assert_eq!(usize::from(first.is_ok()) + usize::from(second.is_ok()), 1);
@@ -116,9 +116,32 @@ fn upload_part_copy_shares_foreground_admission_with_upload_part() {
.expect("list parts");
assert!(parts.parts.is_empty(), "rejected copy must not create a destination part");
drop(held);
let copied = Box::pin(usecase.execute_upload_part_copy(build_request(input, Method::PUT)))
.await
.expect("retry copy after releasing UploadPart permit");
let copied = match Box::pin(usecase.execute_upload_part_copy_with_audit(
owned_envelope(Method::PUT),
UploadPartCopyWriteInput {
target: UploadPartTarget::Legacy {
bucket: input.bucket,
key: input.key,
upload_id: input.upload_id,
},
part_number: input.part_number,
copy_source: rustfs_gateway_types::compat::s3s_5761ddfe::copy_source::from_s3s(input.copy_source),
copy_source_range: input.copy_source_range,
copy_source_if_match: input.copy_source_if_match.map(&condition),
copy_source_if_none_match: input.copy_source_if_none_match.map(&condition),
sse_customer_algorithm: input.sse_customer_algorithm,
sse_customer_key: input.sse_customer_key,
sse_customer_key_md5: input.sse_customer_key_md5,
copy_source_sse_customer_algorithm: input.copy_source_sse_customer_algorithm,
copy_source_sse_customer_key: input.copy_source_sse_customer_key,
copy_source_sse_customer_key_md5: input.copy_source_sse_customer_key_md5,
},
))
.await
{
Ok(output) => output,
Err(error) => panic!("retry copy after releasing UploadPart permit: {error:?}"),
};
assert!(source_reader_observed());
assert_eq!(
manager.put_object_admission_snapshot().active,
@@ -126,14 +149,11 @@ fn upload_part_copy_shares_foreground_admission_with_upload_part() {
"success releases the copy permit"
);
let etag = copied
.output
.copy_part_result
.expect("part result")
.e_tag
.expect("copy ETag")
.value()
.trim_matches('"')
.to_owned();
.as_deref()
.map(crate::storage::storage_api::to_s3s_xml_etag)
.expect("copy ETag");
let etag = etag.value().trim_matches('"').to_owned();
Arc::clone(&store)
.complete_multipart_upload(
&bucket,
+12 -2
View File
@@ -543,8 +543,18 @@ async fn ssec_wire_contract(usecase: &DefaultObjectUsecase, server: &crate::embe
.build()
.unwrap();
{
let (envelope, input) =
crate::app::object_usecase::PutObjectWriteInput::from_test_request(build_request(input, Method::PUT));
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);
crate::app::test_seams::put_object(usecase, envelope, input)
}
.await
+42 -17
View File
@@ -2624,6 +2624,35 @@ 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() {
@@ -2647,7 +2676,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_owned(&usecase, build_request(input, Method::PUT))).await;
let response = Box::pin(put_method_only(&usecase, input)).await;
(response, PUT_STORAGE_TEST_COMPLETION.with(std::cell::Cell::get))
})
.await;
@@ -2746,7 +2775,7 @@ mod tests {
..Default::default()
};
let error = runtime
.block_on(Box::pin(put_extract_owned(&usecase, build_request(input, Method::PUT))))
.block_on(Box::pin(put_extract_method_only(&usecase, input)))
.expect_err("missing archive body");
assert_eq!(error.code(), &S3ErrorCode::IncompleteBody);
assert_eq!(
@@ -2795,7 +2824,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_owned(&usecase, build_request(input, Method::PUT)).await
put_method_only(&usecase, input).await
}),
));
runtime.block_on(std::future::poll_fn(|cx| {
@@ -3291,7 +3320,7 @@ mod tests {
.build()
.expect("PUT input must build");
let put_usecase = DefaultObjectUsecase::with_context(Some(context));
let put = tokio::spawn(async move { put_owned(&put_usecase, build_request(put_input, Method::PUT)).await });
let put = tokio::spawn(async move { put_method_only(&put_usecase, put_input).await });
tokio::time::timeout(Duration::from_secs(2), async {
while !object_traffic_health.snapshot().write_stalled {
tokio::task::yield_now().await;
@@ -3519,8 +3548,7 @@ 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_owned(&zero_copy_usecase, build_request(zero_copy_input, Method::PUT)).await });
let zero_copy_put = tokio::spawn(async move { put_method_only(&zero_copy_usecase, zero_copy_input).await });
tokio::time::timeout(Duration::from_secs(30), async {
while !object_traffic_health.snapshot().write_stalled {
@@ -4596,10 +4624,9 @@ mod tests {
.build()
.unwrap();
let req = build_request(input, Method::PUT);
let usecase = DefaultObjectUsecase::without_context();
let err = Box::pin(put_owned(&usecase, req)).await.unwrap_err();
let err = Box::pin(put_method_only(&usecase, input)).await.unwrap_err();
assert_eq!(err.code(), &S3ErrorCode::InvalidStorageClass);
}
@@ -4821,7 +4848,7 @@ mod tests {
.expect("SSE-C PUT input must build");
let usecase = DefaultObjectUsecase::from_global();
let response = put_owned(&usecase, build_request(input, Method::PUT))
let response = put_method_only(&usecase, input)
.await
.unwrap_or_else(|err| panic!("a {algorithm} default bucket must accept an SSE-C PUT: {err:?}"));
assert_eq!(response.server_side_encryption, None);
@@ -4990,7 +5017,7 @@ mod tests {
.build()
.expect("legacy quota PUT input should build");
let err = put_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
let err = put_method_only(&DefaultObjectUsecase::from_global(), input)
.await
.expect_err("4 GiB used plus a 2 GiB PUT must exceed a 5 GiB legacy quota");
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
@@ -5036,7 +5063,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_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
put_method_only(&DefaultObjectUsecase::from_global(), input)
.await
.expect("a ledger-admitted bucket must accept a write without scanner usage");
@@ -5048,7 +5075,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_owned(&DefaultObjectUsecase::from_global(), build_request(input, Method::PUT))
let err = put_method_only(&DefaultObjectUsecase::from_global(), input)
.await
.expect_err("the ledger must still reject a write above the quota limit");
assert_eq!(err.code(), &S3ErrorCode::InvalidRequest);
@@ -5451,7 +5478,7 @@ mod tests {
.expect("PUT input must build");
let usecase = DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
let err = Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
let err = Box::pin(put_method_only(&usecase, input))
.await
.expect_err("an unreadable bucket encryption configuration must refuse the write");
@@ -5496,9 +5523,7 @@ mod tests {
metrics::with_local_recorder(&recorder, || {
request.in_scope(|| {
runtime.block_on(async {
Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
.await
.expect("S3 PUT must commit");
Box::pin(put_method_only(&usecase, input)).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);
})
@@ -5563,7 +5588,7 @@ mod tests {
.expect("PUT input must build");
let usecase = DefaultObjectUsecase::with_context(Some(Arc::clone(&context)));
Box::pin(put_owned(&usecase, build_request(input, Method::PUT)))
Box::pin(put_method_only(&usecase, input))
.await
.expect("a bucket without default encryption must still accept a plaintext write");