mirror of
https://github.com/rustfs/rustfs.git
synced 2026-11-22 16:02:46 +00:00
Compare commits
14 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 9b6d60e934 | |||
| bb94ec983b | |||
| 6a1b92b783 | |||
| 818a6b6a14 | |||
| 67d306b0de | |||
| a6f881b42d | |||
| dba23c4f55 | |||
| 0d17f5f713 | |||
| e09df1f7cd | |||
| c5c65e112e | |||
| dfa3d7a2cd | |||
| 578025149b | |||
| bfc51cf3da | |||
| 78b35c3ea8 |
@@ -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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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");
|
||||
|
||||
|
||||
Reference in New Issue
Block a user