mirror of
https://github.com/rustfs/rustfs.git
synced 2026-11-22 16:02:46 +00:00
Compare commits
3 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 9b6d60e934 | |||
| bb94ec983b | |||
| 6a1b92b783 |
@@ -46,8 +46,6 @@ 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.
|
||||
|
||||
@@ -789,315 +789,4 @@ 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");
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -588,15 +588,8 @@ 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
|
||||
@@ -604,6 +597,9 @@ 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();
|
||||
|
||||
@@ -436,9 +436,7 @@ impl DefaultMultipartUsecase {
|
||||
bucket,
|
||||
key,
|
||||
upload_id,
|
||||
// `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()),
|
||||
server_side_encryption: effective_sse,
|
||||
sse_customer_algorithm,
|
||||
sse_customer_key_md5,
|
||||
ssekms_key_id: effective_kms_key_id,
|
||||
|
||||
@@ -402,8 +402,7 @@ impl DefaultMultipartUsecase {
|
||||
}
|
||||
};
|
||||
write_plan = write_plan.with_encryption(ssec_write);
|
||||
// An SSE-C part answers with its customer-key headers only.
|
||||
(None, None)
|
||||
(Some(ssec_material.server_side_encryption), ssec_material.kms_key_id)
|
||||
} 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,8 +474,11 @@ impl DefaultMultipartUsecase {
|
||||
}
|
||||
};
|
||||
write_plan = write_plan.with_encryption(ssec_write);
|
||||
// An SSE-C part answers with its customer-key headers only.
|
||||
(None, None, mp_info.user_defined.clone())
|
||||
(
|
||||
Some(ssec_material.server_side_encryption),
|
||||
ssec_material.kms_key_id,
|
||||
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.
|
||||
|
||||
@@ -904,9 +904,7 @@ impl DefaultObjectUsecase {
|
||||
last_modified: oi.mod_time,
|
||||
copy_source_version_id,
|
||||
version_id: dest_version,
|
||||
// `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()),
|
||||
server_side_encryption: effective_sse,
|
||||
ssekms_key_id: effective_kms_key_id,
|
||||
sse_customer_algorithm,
|
||||
sse_customer_key_md5,
|
||||
@@ -1485,74 +1483,6 @@ 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.
|
||||
|
||||
@@ -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