use super::*;
impl BucketWarden {
pub(crate) fn dispatch_bucket_get_s3_http(
&mut self,
request: S3HttpRequest,
bucket: &str,
) -> Result<S3HttpResponse, RuntimeError> {
let key: Option<&str> = None;
match ("GET", Some(bucket), key) {
("GET", Some(bucket), None) if request.query.contains_key("location") => {
let result = self.get_bucket_location(&request.principal, bucket)?;
Ok(xml_response(200, bucket_location_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("acl") => {
let result = self.get_bucket_acl(&request.principal, bucket)?;
Ok(xml_response(200, acl_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("ownershipControls") => {
let result = self.get_bucket_ownership_controls(&request.principal, bucket)?;
Ok(xml_response(200, bucket_ownership_controls_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("cors") => {
let result = self.get_bucket_cors(&request.principal, bucket)?;
Ok(xml_response(200, bucket_cors_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("logging") => {
let result = self.get_bucket_logging(&request.principal, bucket)?;
Ok(xml_response(200, bucket_logging_status_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("website") => {
let result = self.get_bucket_website(&request.principal, bucket)?;
Ok(xml_response(200, bucket_website_configuration_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("policy") => {
let result = self.get_bucket_policy(&request.principal, bucket)?;
Ok(S3HttpResponse::new(200)
.with_header("content-type", "application/json")
.with_body(result.policy_json))
}
("GET", Some(bucket), None) if request.query.contains_key("policyStatus") => {
let result = self.get_bucket_policy_status(&request.principal, bucket)?;
Ok(xml_response(200, bucket_policy_status_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("abac") => {
let result = self.get_bucket_abac(&request.principal, bucket)?;
Ok(xml_response(200, bucket_abac_status_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("tagging") => {
let result = self.get_bucket_tagging(&request.principal, bucket)?;
Ok(xml_response(200, bucket_tagging_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("session") => {
let result = self.create_session(
&request.principal,
parse_create_session_request(bucket, &request.headers)?,
)?;
let mut response = xml_response(200, create_session_result_xml(&result));
if let Some(algorithm) = result.server_side_encryption.as_ref() {
response =
response.with_header("x-amz-server-side-encryption", algorithm.clone());
}
if let Some(kms_key_id) = result.kms_key_id.as_ref() {
response = response.with_header(
"x-amz-server-side-encryption-aws-kms-key-id",
kms_key_id.clone(),
);
}
if let Some(encryption_context) = result.encryption_context.as_ref() {
response = response.with_header(
"x-amz-server-side-encryption-context",
encryption_context.clone(),
);
}
if let Some(bucket_key_enabled) = result.bucket_key_enabled {
response = response.with_header(
"x-amz-server-side-encryption-bucket-key-enabled",
bucket_key_enabled.to_string(),
);
}
Ok(response)
}
("GET", Some(bucket), None) if request.query.contains_key("requestPayment") => {
let result = self.get_bucket_request_payment(&request.principal, bucket)?;
Ok(xml_response(200, bucket_request_payment_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("accelerate") => {
let result =
self.get_bucket_accelerate_configuration(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_accelerate_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("publicAccessBlock") => {
let result = self.get_public_access_block(&request.principal, bucket)?;
Ok(xml_response(
200,
public_access_block_configuration_xml(&result),
))
}
("GET", Some(bucket), None)
if request.query.contains_key("metrics") && request.query.contains_key("id") =>
{
let id = request.query.get("id").expect("guarded metrics id");
let result =
self.get_bucket_metrics_configuration(&request.principal, bucket, id)?;
Ok(xml_response(200, bucket_metrics_configuration_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("metrics") => {
let result = self.list_bucket_metrics_configurations(
&request.principal,
bucket,
request.query.get("continuation-token").map(String::as_str),
)?;
Ok(xml_response(
200,
list_bucket_metrics_configurations_xml(&result),
))
}
("GET", Some(bucket), None)
if request.query.contains_key("analytics") && request.query.contains_key("id") =>
{
let id = request.query.get("id").expect("guarded analytics id");
let result =
self.get_bucket_analytics_configuration(&request.principal, bucket, id)?;
Ok(xml_response(
200,
bucket_analytics_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("analytics") => {
let result = self.list_bucket_analytics_configurations(
&request.principal,
bucket,
request.query.get("continuation-token").map(String::as_str),
)?;
Ok(xml_response(
200,
list_bucket_analytics_configurations_xml(&result),
))
}
("GET", Some(bucket), None)
if request.query.contains_key("inventory") && request.query.contains_key("id") =>
{
let id = request.query.get("id").expect("guarded inventory id");
let result =
self.get_bucket_inventory_configuration(&request.principal, bucket, id)?;
Ok(xml_response(
200,
bucket_inventory_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("inventory") => {
let result = self.list_bucket_inventory_configurations(
&request.principal,
bucket,
request.query.get("continuation-token").map(String::as_str),
)?;
Ok(xml_response(
200,
list_bucket_inventory_configurations_xml(&result),
))
}
("GET", Some(bucket), None)
if request.query.contains_key("intelligent-tiering")
&& request.query.contains_key("id") =>
{
let id = request
.query
.get("id")
.expect("guarded intelligent-tiering id");
let result = self.get_bucket_intelligent_tiering_configuration(
&request.principal,
bucket,
id,
)?;
Ok(xml_response(
200,
bucket_intelligent_tiering_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("intelligent-tiering") => {
let result = self.list_bucket_intelligent_tiering_configurations(
&request.principal,
bucket,
request.query.get("continuation-token").map(String::as_str),
)?;
Ok(xml_response(
200,
list_bucket_intelligent_tiering_configurations_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("metadataConfiguration") => {
let result = self.get_bucket_metadata_configuration(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_metadata_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("metadataTable") => {
let result =
self.get_bucket_metadata_table_configuration(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_metadata_table_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("object-lock") => {
let result =
self.get_bucket_object_lock_configuration(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_object_lock_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("encryption") => {
let result = self.get_bucket_encryption(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_encryption_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("lifecycle") => {
let result = self.get_bucket_lifecycle(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_lifecycle_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("notification") => {
let result = self.get_bucket_notification(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_notification_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("replication") => {
let result = self.get_bucket_replication(&request.principal, bucket)?;
Ok(xml_response(
200,
bucket_replication_configuration_xml(&result),
))
}
("GET", Some(bucket), None) if request.query.contains_key("versioning") => {
let result = self.get_bucket_versioning(&request.principal, bucket)?;
Ok(xml_response(200, bucket_versioning_xml(&result)))
}
("GET", Some(_bucket), None) if request.query.contains_key("torrent") => {
Ok(general_error_response(
"RequestTorrentOfBucketError",
400,
"Requesting the torrent file of a bucket is not permitted.",
))
}
("GET", Some(bucket), None) if request.query.contains_key("versions") => {
let result = self.list_object_versions(
&request.principal,
ListObjectVersionsRequest {
bucket: bucket.to_string(),
prefix: request.query.get("prefix").cloned(),
key_marker: request.query.get("key-marker").cloned(),
version_id_marker: request.query.get("version-id-marker").cloned(),
max_keys: request
.query
.get("max-keys")
.map(|value| parse_max_keys(value))
.transpose()?,
encoding_type: request.query.get("encoding-type").cloned(),
},
)?;
Ok(xml_response(200, list_object_versions_xml(&result)))
}
("GET", Some(bucket), None) if request.query.contains_key("uploads") => {
let result = self.list_multipart_uploads(
&request.principal,
bucket,
request.query.get("prefix").map(String::as_str),
request.query.get("key-marker").map(String::as_str),
request.query.get("upload-id-marker").map(String::as_str),
request
.query
.get("max-uploads")
.map(|value| parse_max_keys(value))
.transpose()?,
)?;
Ok(xml_response(200, list_multipart_uploads_xml(&result)))
}
("GET", Some(bucket), None) => {
let list_type_v2 = request
.query
.get("list-type")
.is_some_and(|value| value == "2");
let result = self.list_objects(
&request.principal,
ListObjectsRequest {
bucket: bucket.to_string(),
prefix: request.query.get("prefix").cloned(),
delimiter: request.query.get("delimiter").cloned(),
max_keys: request
.query
.get("max-keys")
.map(|value| parse_max_keys(value))
.transpose()?,
marker: (!list_type_v2)
.then(|| request.query.get("marker").cloned())
.flatten(),
continuation_token: list_type_v2
.then(|| request.query.get("continuation-token").cloned())
.flatten(),
start_after: list_type_v2
.then(|| request.query.get("start-after").cloned())
.flatten(),
encoding_type: request.query.get("encoding-type").cloned(),
},
)?;
Ok(xml_response(200, list_objects_xml(&result, list_type_v2)))
}
_ => Ok(general_error_response(
"MethodNotAllowed",
405,
"The specified method is not allowed for this resource.",
)),
}
}
}