Compare commits

..

7 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
7 changed files with 131 additions and 485 deletions
+6 -23
View File
@@ -974,18 +974,12 @@ impl ReadPlan {
let _ = sequence_number;
let decrypted_reader: Box<dyn AsyncRead + Unpin + Send + Sync> = if is_multipart {
match material.mode {
ReadEncryptionMode::Object => {
// The rio-v2 reader fails a stream that ends before a
// listed part, so it must not hear about empty ones.
#[cfg(feature = "rio-v2")]
let part_numbers = without_empty_parts(part_numbers, &oi.parts);
crate::io_support::rio::decrypt_multipart_reader_with_object_key(
reader,
material.key_bytes,
part_numbers,
sequence_number,
)
}
ReadEncryptionMode::Object => crate::io_support::rio::decrypt_multipart_reader_with_object_key(
reader,
material.key_bytes,
part_numbers,
sequence_number,
),
ReadEncryptionMode::Direct { base_nonce } => crate::io_support::rio::decrypt_multipart_reader(
reader,
material.key_bytes,
@@ -1440,17 +1434,6 @@ fn multipart_part_numbers(parts: &[ObjectPartInfo]) -> Vec<usize> {
parts.iter().map(|part| part.number).collect()
}
/// Drops from `part_numbers` the parts that stored no bytes: a DARE writer
/// emits no package for an empty part, so none follows on disk.
#[cfg(feature = "rio-v2")]
fn without_empty_parts(mut part_numbers: Vec<usize>, parts: &[ObjectPartInfo]) -> Vec<usize> {
let empty_parts: Vec<usize> = parts.iter().filter(|part| part.size == 0).map(|part| part.number).collect();
if !empty_parts.is_empty() {
part_numbers.retain(|number| !empty_parts.contains(number));
}
part_numbers
}
#[cfg(test)]
mod tests {
use super::*;
-218
View File
@@ -7194,224 +7194,6 @@ mod legacy_duplex_producer_reader_tests {
}
}
#[cfg(feature = "rio-v2")]
struct ObjectKeyResolver {
object_key: [u8; 32],
}
#[cfg(feature = "rio-v2")]
#[async_trait::async_trait]
impl ObjectEncryptionResolver for ObjectKeyResolver {
async fn resolve_read_material(
&self,
_request: crate::object_api::ReadEncryptionRequest<'_>,
) -> std::result::Result<Option<ReadEncryptionMaterial>, EncryptionResolutionError> {
Ok(Some(ReadEncryptionMaterial {
key_bytes: self.object_key,
mode: ReadEncryptionMode::Object,
}))
}
}
#[cfg(feature = "rio-v2")]
const RIO_V2_FIXTURE_OBJECT_KEY: [u8; 32] = [0x67; 32];
#[cfg(feature = "rio-v2")]
fn rio_v2_fixture_plaintext(len: usize, seed: usize) -> Vec<u8> {
(0..len)
.map(|index| u8::try_from((index + seed) % 251).expect("a remainder below 251 fits in u8"))
.collect()
}
/// Reads a rio-v2 encrypted object the way the legacy GET path does: a
/// producer task feeds the stored bytes into a pipe sized by
/// `adaptive_duplex_buffer_size`, so the decrypt reader sees `Pending`
/// wherever a DARE package outruns the pipe. `parts` lists each part's
/// `(plaintext, stored)` length as the object metadata records it, and
/// `stored` is what the drives actually hold, which a test may cut short.
#[cfg(feature = "rio-v2")]
async fn read_rio_v2_object_through_get_pipe(
stored: Vec<u8>,
parts: &[(usize, usize)],
range: Option<HTTPRangeSpec>,
) -> std::io::Result<Vec<u8>> {
let plaintext_size: usize = parts.iter().map(|(plaintext_len, _)| plaintext_len).sum();
let multipart = parts.len() > 1;
let object_info = ObjectInfo {
bucket: "bucket".to_string(),
name: "rio-v2-encrypted-object".to_string(),
size: i64::try_from(parts.iter().map(|(_, stored_len)| stored_len).sum::<usize>())
.expect("stored fixture length should fit in i64"),
etag: multipart.then(|| format!("{}-{}", "0".repeat(32), parts.len())),
parts: Arc::new(if multipart {
parts
.iter()
.enumerate()
.map(|(index, (plaintext_len, stored_len))| rustfs_filemeta::ObjectPartInfo {
number: index + 1,
size: *stored_len,
actual_size: i64::try_from(*plaintext_len).expect("part plaintext length should fit in i64"),
..Default::default()
})
.collect()
} else {
Vec::new()
}),
user_defined: Arc::new(HashMap::from([
("x-amz-server-side-encryption-customer-algorithm".to_string(), "AES256".to_string()),
(
"x-amz-server-side-encryption-customer-original-size".to_string(),
plaintext_size.to_string(),
),
])),
..Default::default()
};
let ctx = InstanceContext::new();
assert!(
ctx.set_object_encryption_resolver(Arc::new(ObjectKeyResolver {
object_key: RIO_V2_FIXTURE_OBJECT_KEY
}))
.is_ok(),
"fresh context should accept resolver"
);
let (mut writer, reader) = tokio::io::duplex(adaptive_duplex_buffer_size(object_info.size));
let (terminal_tx, terminal_rx) = tokio::sync::oneshot::channel();
let (mut reader, storage_offset, storage_length) = get_legacy_object_reader_with_context(
&ctx,
reader,
terminal_rx,
range,
&object_info,
&ObjectOptions::default(),
&HeaderMap::new(),
)
.await
.expect("encrypted read plan should build");
let storage_length = usize::try_from(storage_length).expect("storage length should not be negative");
let producer = tokio::spawn(async move {
let window_end = stored.len().min(storage_offset + storage_length);
let window_start = storage_offset.min(window_end);
let written = writer.write_all(&stored[window_start..window_end]).await;
drop(writer);
// The reader may already have failed and dropped the receiver.
let _ = terminal_tx.send(Ok(()));
written
});
let mut out = Vec::new();
let read = reader.read_to_end(&mut out).await;
drop(reader);
// A failed read drops the pipe early, so the producer's own result only
// matters once the read itself succeeded.
let written = producer.await.expect("producer task should not panic");
read?;
written?;
Ok(out)
}
#[cfg(feature = "rio-v2")]
#[tokio::test]
async fn rio_v2_encrypted_get_survives_pipe_refills_mid_package() {
const MIB: usize = 1024 * 1024;
// Stored sizes up to 128 KiB get a 64 KiB pipe, smaller than one DARE
// package; 3 MiB objects get a 1 MiB pipe that packages straddle.
let mut failures = Vec::new();
for plaintext_len in [65_535, 65_536, 65_537, 71_680, 3 * MIB, 3 * MIB + 1] {
let plaintext = rio_v2_fixture_plaintext(plaintext_len, 0);
let mut stored = Vec::new();
crate::io_support::rio::EncryptReader::new_with_object_key(
std::io::Cursor::new(plaintext.clone()),
RIO_V2_FIXTURE_OBJECT_KEY,
)
.read_to_end(&mut stored)
.await
.expect("encrypt singlepart fixture");
let stored_len = stored.len();
match read_rio_v2_object_through_get_pipe(stored, &[(plaintext_len, stored_len)], None).await {
Ok(out) if out == plaintext => {}
Ok(_) => failures.push(format!("{plaintext_len}-byte object: plaintext mismatch")),
Err(err) => failures.push(format!("{plaintext_len}-byte object: {err}")),
}
}
assert!(failures.is_empty(), "rio-v2 encrypted GET failed for: {failures:#?}");
}
#[cfg(feature = "rio-v2")]
#[tokio::test]
async fn rio_v2_encrypted_multipart_get_survives_pipe_refills_mid_package() {
const MIB: usize = 1024 * 1024;
let part_plaintexts = [rio_v2_fixture_plaintext(5 * MIB, 1), rio_v2_fixture_plaintext(MIB + 17, 2)];
let (stored, parts) = rio_v2_multipart_fixture(&part_plaintexts).await;
let out = read_rio_v2_object_through_get_pipe(stored, &parts, None)
.await
.expect("read multipart object through the GET pipe");
assert!(out == part_plaintexts.concat(), "multipart plaintext mismatch");
}
/// Encrypts each part with its own part key and returns the concatenated
/// stored stream with every part's `(plaintext, stored)` length.
#[cfg(feature = "rio-v2")]
async fn rio_v2_multipart_fixture(part_plaintexts: &[Vec<u8>]) -> (Vec<u8>, Vec<(usize, usize)>) {
let mut stored = Vec::new();
let mut parts = Vec::new();
for (part_number, part_plaintext) in (1u32..).zip(part_plaintexts) {
let stored_before = stored.len();
crate::io_support::rio::EncryptReader::new_multipart_with_object_key(
std::io::Cursor::new(part_plaintext.clone()),
RIO_V2_FIXTURE_OBJECT_KEY,
part_number,
)
.read_to_end(&mut stored)
.await
.expect("encrypt multipart fixture part");
parts.push((part_plaintext.len(), stored.len() - stored_before));
}
(stored, parts)
}
#[cfg(feature = "rio-v2")]
#[tokio::test]
async fn rio_v2_encrypted_multipart_range_get_rejects_a_missing_trailing_part() {
let part_plaintexts = [rio_v2_fixture_plaintext(70_000, 1), rio_v2_fixture_plaintext(140_000, 2)];
let (mut stored, parts) = rio_v2_multipart_fixture(&part_plaintexts).await;
// The drives hold part 1 only, although the metadata still lists part 2.
stored.truncate(parts[0].1);
// The range starts in part 1 and ends inside the missing part 2.
let range = HTTPRangeSpec {
is_suffix_length: false,
start: 69_900,
end: 70_099,
};
let outcome = read_rio_v2_object_through_get_pipe(stored, &parts, Some(range)).await;
match outcome {
Err(err) => assert_eq!(err.kind(), std::io::ErrorKind::UnexpectedEof, "{err}"),
Ok(out) => panic!("a 200-byte range over a missing part read {} bytes as a clean EOF", out.len()),
}
}
#[cfg(feature = "rio-v2")]
#[tokio::test]
async fn rio_v2_encrypted_multipart_get_accepts_an_empty_trailing_part() {
let part_plaintexts = [rio_v2_fixture_plaintext(70_000, 1), Vec::new()];
let (stored, parts) = rio_v2_multipart_fixture(&part_plaintexts).await;
assert_eq!(parts[1], (0, 0), "an empty part stores no DARE package");
let out = read_rio_v2_object_through_get_pipe(stored, &parts, None)
.await
.expect("an empty trailing part is not a truncated stream");
assert!(out == part_plaintexts[0], "plaintext mismatch for an object with an empty trailing part");
}
#[tokio::test]
async fn legacy_duplex_reader_fails_closed_when_terminal_channel_closes() {
let (mut writer, reader) = tokio::io::duplex(64);
+4 -183
View File
@@ -334,23 +334,14 @@ where
}
}
/// See [`Self::new_multipart_with_sequence`] for the `multipart_parts` contract.
pub fn new_multipart(inner: R, key: [u8; 32], base_nonce: [u8; 12], multipart_parts: Vec<usize>) -> Self {
Self::new_multipart_with_sequence(inner, key, base_nonce, multipart_parts, 0)
}
/// See [`Self::new_multipart_with_object_key_and_sequence`] for the `multipart_parts` contract.
pub fn new_multipart_with_object_key(inner: R, object_key: [u8; 32], multipart_parts: Vec<usize>) -> Self {
Self::new_multipart_with_object_key_and_sequence(inner, object_key, multipart_parts, 0)
}
/// Decrypts the concatenated package sequences of `multipart_parts`, in
/// order, starting at package `sequence_number` of the first one.
///
/// List only the parts that stored bytes: an empty part has no package on
/// disk, and reading fails with [`io::ErrorKind::UnexpectedEof`] when the
/// stream ends before a listed part's final package, including on the
/// boundary before a listed part.
pub fn new_multipart_with_sequence(
inner: R,
key: [u8; 32],
@@ -382,14 +373,6 @@ where
}
}
/// Decrypts the concatenated package sequences of `multipart_parts`, in
/// order, deriving each part key from `object_key` and starting at package
/// `sequence_number` of the first one.
///
/// List only the parts that stored bytes: an empty part has no package on
/// disk, and reading fails with [`io::ErrorKind::UnexpectedEof`] when the
/// stream ends before a listed part's final package, including on the
/// boundary before a listed part.
pub fn new_multipart_with_object_key_and_sequence(
inner: R,
object_key: [u8; 32],
@@ -483,24 +466,15 @@ where
// with `finalized == false` (the finalized case is consumed at the
// loop top). If at least one package of the current part has been
// decrypted (`ref_nonce.is_some()`) but we never saw a final-flagged
// package, the final package is missing => DARE truncation.
// package, the final package is missing => DARE truncation. Zero
// decrypted packages (`ref_nonce.is_none()`) is a legitimately empty
// object (encrypt emits no packages for empty plaintext), so accept.
if this.ref_nonce.is_some() {
return Poll::Ready(Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"DARE stream truncated before a finalized package",
)));
}
// Zero decrypted packages. A listed part always carries at least
// one package, so the stream ended before that part: without this
// a stream cut exactly on a part boundary reads as complete.
if let Some(missing_part) = this.multipart_parts.get(*this.current_part_index) {
return Poll::Ready(Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
format!("DARE stream ended before multipart part {missing_part}"),
)));
}
// No part is expected here: a legitimately empty object (encrypt
// emits no packages for empty plaintext), so accept.
*this.finished = true;
return Poll::Ready(Ok(()));
}
@@ -539,11 +513,8 @@ where
if this.ciphertext_buf.len() < package_len {
this.ciphertext_buf.resize(package_len, 0);
}
// `ciphertext_read` is zero when a package starts and is reset only
// once that package is opened: a `Pending` below re-enters here with
// the header already buffered and must resume after the ciphertext
// already read rather than refill the buffer from its start.
*this.ciphertext_len = package_len;
*this.ciphertext_read = 0;
while *this.ciphertext_read < *this.ciphertext_len {
let mut read_buf = ReadBuf::new(&mut this.ciphertext_buf[*this.ciphertext_read..*this.ciphertext_len]);
@@ -1013,154 +984,4 @@ mod tests {
.expect_err("multipart stream truncated within a part must fail");
assert_eq!(err.kind(), io::ErrorKind::UnexpectedEof);
}
#[tokio::test]
async fn multipart_decrypt_reader_rejects_a_stream_missing_a_listed_part() {
let object_key = [0x64u8; 32];
let part_plaintexts = [vec![0xA1; DARE_PAYLOAD_SIZE + 31], vec![0xB2; DARE_PAYLOAD_SIZE * 2 + 7]];
let mut encrypted_parts = Vec::new();
for (part_number, part_plaintext) in (1u32..).zip(&part_plaintexts) {
let mut encrypted = Vec::new();
EncryptReader::new_multipart_with_object_key(Cursor::new(part_plaintext.clone()), object_key, part_number)
.read_to_end(&mut encrypted)
.await
.expect("encrypt multipart part");
encrypted_parts.push(encrypted);
}
// Every stream below ends on a part boundary, right after a
// final-flagged package, with a listed part still undelivered.
for (stream, listed_parts) in [
(encrypted_parts[0].clone(), vec![1, 2]),
(encrypted_parts.concat(), vec![1, 2, 3]),
(Vec::new(), vec![1]),
] {
let mut sink = Vec::new();
let outcome = DecryptReader::new_multipart_with_object_key(Cursor::new(stream), object_key, listed_parts.clone())
.read_to_end(&mut sink)
.await;
match outcome {
Err(err) => assert_eq!(err.kind(), io::ErrorKind::UnexpectedEof, "parts {listed_parts:?}: {err}"),
Ok(read) => panic!("parts {listed_parts:?}: a stream missing a listed part read {read} bytes as a clean EOF"),
}
}
}
#[tokio::test]
async fn multipart_decrypt_reader_accepts_an_empty_stream_without_listed_parts() {
let mut decrypted = Vec::new();
DecryptReader::new_multipart_with_object_key(Cursor::new(Vec::new()), [0x64u8; 32], Vec::new())
.read_to_end(&mut decrypted)
.await
.expect("an object whose parts all stored no bytes is empty, not truncated");
assert!(decrypted.is_empty());
}
/// A bounded pipe whose producer lags the consumer: it hands out at most
/// `capacity` bytes, then reports `Pending` once before the next refill.
struct RefillingPipe {
data: Vec<u8>,
position: usize,
capacity: usize,
available: usize,
}
impl RefillingPipe {
fn new(data: Vec<u8>, capacity: usize) -> Self {
Self {
data,
position: 0,
capacity,
available: capacity,
}
}
}
impl AsyncRead for RefillingPipe {
fn poll_read(mut self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &mut ReadBuf<'_>) -> Poll<io::Result<()>> {
let unread = self.data.len() - self.position;
if unread > 0 && self.available == 0 {
self.available = self.capacity;
cx.waker().wake_by_ref();
return Poll::Pending;
}
let len = min(min(unread, self.available), buf.remaining());
let start = self.position;
buf.put_slice(&self.data[start..start + len]);
self.position += len;
self.available -= len;
Poll::Ready(Ok(()))
}
}
fn patterned_plaintext(len: usize, seed: usize) -> Vec<u8> {
(0..len)
.map(|index| u8::try_from((index + seed) % 251).expect("a remainder below 251 fits in u8"))
.collect()
}
#[tokio::test]
async fn decrypt_reader_resumes_a_package_after_pending_mid_ciphertext() {
const KIB: usize = 1024;
const MIB: usize = 1024 * KIB;
let object_key = [0x3Du8; 32];
// (plaintext length, pipe capacity). The first group is a single package
// slightly larger than a 64 KiB pipe; the second is a multi-package stream
// whose packages straddle 1 MiB refills; the last drains byte by byte so
// every header and ciphertext position sees a `Pending`.
let mut failures = Vec::new();
for (plaintext_len, capacity) in [
(DARE_PAYLOAD_SIZE - 1, 64 * KIB),
(DARE_PAYLOAD_SIZE, 64 * KIB),
(DARE_PAYLOAD_SIZE + 1, 64 * KIB),
(70 * KIB, 64 * KIB),
(3 * MIB, MIB),
(3 * MIB + 1, MIB),
(DARE_PAYLOAD_SIZE + 17, 1),
] {
let plaintext = patterned_plaintext(plaintext_len, capacity);
let mut encrypted = Vec::new();
EncryptReader::new_with_object_key(Cursor::new(plaintext.clone()), object_key)
.read_to_end(&mut encrypted)
.await
.expect("encrypt singlepart stream");
let mut decrypted = Vec::new();
let outcome = DecryptReader::new_with_object_key(RefillingPipe::new(encrypted, capacity), object_key)
.read_to_end(&mut decrypted)
.await;
match outcome {
Ok(_) if decrypted == plaintext => {}
Ok(_) => failures.push(format!("{plaintext_len} bytes through a {capacity}-byte pipe: plaintext mismatch")),
Err(err) => failures.push(format!("{plaintext_len} bytes through a {capacity}-byte pipe: {err}")),
}
}
assert!(failures.is_empty(), "decrypt failed for: {failures:#?}");
}
#[tokio::test]
async fn multipart_decrypt_reader_resumes_a_package_after_pending_mid_ciphertext() {
const MIB: usize = 1024 * 1024;
let object_key = [0x5Eu8; 32];
let part_plaintexts = [patterned_plaintext(5 * MIB, 1), patterned_plaintext(MIB + 17, 2)];
let mut encrypted = Vec::new();
for (part_number, part_plaintext) in (1u32..).zip(&part_plaintexts) {
EncryptReader::new_multipart_with_object_key(Cursor::new(part_plaintext.clone()), object_key, part_number)
.read_to_end(&mut encrypted)
.await
.expect("encrypt multipart part");
}
let mut decrypted = Vec::new();
DecryptReader::new_multipart_with_object_key(RefillingPipe::new(encrypted, MIB), object_key, vec![1, 2])
.read_to_end(&mut decrypted)
.await
.expect("decrypt multipart stream through a 1 MiB pipe");
assert!(decrypted == part_plaintexts.concat(), "multipart plaintext mismatch through a 1 MiB pipe");
}
}
+37 -32
View File
@@ -1614,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(),
@@ -1651,7 +1651,9 @@ 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()
}]),
}),
@@ -1820,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())
@@ -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");