impl ListObjectsInput {
#[allow(unused_mut)]
#[allow(clippy::let_and_return)]
#[allow(clippy::needless_borrow)]
pub async fn make_operation(
&self,
_config: &crate::config::Config,
) -> ::std::result::Result<
::aws_smithy_http::operation::Operation<
crate::operation::list_objects::ListObjects,
::aws_http::retry::AwsResponseRetryClassifier,
>,
::aws_smithy_http::operation::error::BuildError,
> {
let params_result = crate::endpoint::Params::builder()
.set_region(_config.region.as_ref().map(|r| r.as_ref().to_owned()))
.set_use_fips(_config.use_fips)
.set_use_dual_stack(_config.use_dual_stack)
.set_endpoint(_config.endpoint_url.clone())
.set_force_path_style(_config.force_path_style)
.set_use_arn_region(_config.use_arn_region)
.set_disable_multi_region_access_points(_config.disable_multi_region_access_points)
.set_accelerate(_config.accelerate)
.set_bucket(self.bucket.clone())
.build()
.map_err(|err| {
::aws_smithy_http::endpoint::ResolveEndpointError::from_source(
"could not construct endpoint parameters",
err,
)
});
let (endpoint_result, params) = match params_result {
::std::result::Result::Ok(params) => (
_config.endpoint_resolver.resolve_endpoint(¶ms),
::std::option::Option::Some(params),
),
::std::result::Result::Err(e) => {
(::std::result::Result::Err(e), ::std::option::Option::None)
}
};
let mut request = {
fn uri_base(
_input: &crate::operation::list_objects::ListObjectsInput,
output: &mut ::std::string::String,
) -> ::std::result::Result<(), ::aws_smithy_http::operation::error::BuildError>
{
use ::std::fmt::Write as _;
::std::write!(output, "/").expect("formatting should succeed");
::std::result::Result::Ok(())
}
fn uri_query(
_input: &crate::operation::list_objects::ListObjectsInput,
mut output: &mut ::std::string::String,
) -> ::std::result::Result<(), ::aws_smithy_http::operation::error::BuildError>
{
let mut query = ::aws_smithy_http::query::Writer::new(output);
if let ::std::option::Option::Some(inner_1) = &_input.delimiter {
{
query.push_kv("delimiter", &::aws_smithy_http::query::fmt_string(&inner_1));
}
}
if let ::std::option::Option::Some(inner_2) = &_input.encoding_type {
{
query.push_kv(
"encoding-type",
&::aws_smithy_http::query::fmt_string(&inner_2),
);
}
}
if let ::std::option::Option::Some(inner_3) = &_input.marker {
{
query.push_kv("marker", &::aws_smithy_http::query::fmt_string(&inner_3));
}
}
if let ::std::option::Option::Some(inner_4) = &_input.max_keys {
if *inner_4 != 0 {
query.push_kv(
"max-keys",
::aws_smithy_types::primitive::Encoder::from(*inner_4).encode(),
);
}
}
if let ::std::option::Option::Some(inner_5) = &_input.prefix {
{
query.push_kv("prefix", &::aws_smithy_http::query::fmt_string(&inner_5));
}
}
::std::result::Result::Ok(())
}
#[allow(clippy::unnecessary_wraps)]
fn update_http_builder(
input: &crate::operation::list_objects::ListObjectsInput,
builder: ::http::request::Builder,
) -> ::std::result::Result<
::http::request::Builder,
::aws_smithy_http::operation::error::BuildError,
> {
let mut uri = ::std::string::String::new();
uri_base(input, &mut uri)?;
uri_query(input, &mut uri)?;
let builder = crate::protocol_serde::shape_list_objects::ser_list_objects_headers(
input, builder,
)?;
::std::result::Result::Ok(builder.method("GET").uri(uri))
}
let mut builder = update_http_builder(&self, ::http::request::Builder::new())?;
builder
};
let mut properties = ::aws_smithy_http::property_bag::SharedPropertyBag::new();
#[allow(clippy::useless_conversion)]
let body = ::aws_smithy_http::body::SdkBody::from("");
let request = request.body(body).expect("should be valid request");
let mut request = ::aws_smithy_http::operation::Request::from_parts(request, properties);
request.properties_mut().insert(endpoint_result);
if let ::std::option::Option::Some(params) = params {
request.properties_mut().insert(params);
}
request
.properties_mut()
.insert(::aws_smithy_http::http_versions::DEFAULT_HTTP_VERSION_LIST.clone());
let mut user_agent = ::aws_http::user_agent::AwsUserAgent::new_from_environment(
::aws_types::os_shim_internal::Env::real(),
crate::meta::API_METADATA.clone(),
);
if let Some(app_name) = _config.app_name() {
user_agent = user_agent.with_app_name(app_name.clone());
}
request.properties_mut().insert(user_agent);
let mut signing_config = ::aws_sig_auth::signer::OperationSigningConfig::default_config();
signing_config.signing_options.content_sha256_header = true;
signing_config.signing_options.double_uri_encode = false;
signing_config.signing_options.normalize_uri_path = false;
request.properties_mut().insert(signing_config);
request
.properties_mut()
.insert(::aws_types::SigningService::from_static(
_config.signing_service(),
));
if let Some(region) = &_config.region {
request
.properties_mut()
.insert(::aws_types::region::SigningRegion::from(region.clone()));
}
if let Some(region) = &_config.region {
request.properties_mut().insert(region.clone());
}
::aws_http::auth::set_credentials_cache(
&mut request.properties_mut(),
_config.credentials_cache.clone(),
);
let op = ::aws_smithy_http::operation::Operation::new(
request,
crate::operation::list_objects::ListObjects::new(),
)
.with_metadata(::aws_smithy_http::operation::Metadata::new(
"ListObjects",
"s3",
));
let op = op.with_retry_classifier(::aws_http::retry::AwsResponseRetryClassifier::new());
::std::result::Result::Ok(op)
}
}
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
#[non_exhaustive]
#[doc(hidden)]
pub struct ListObjects;
impl ListObjects {
#[doc(hidden)]
pub fn new() -> Self {
Self
}
}
impl ::aws_smithy_http::response::ParseStrictResponse for ListObjects {
type Output = ::std::result::Result<
crate::operation::list_objects::ListObjectsOutput,
crate::operation::list_objects::ListObjectsError,
>;
fn parse(&self, response: &::http::Response<::bytes::Bytes>) -> Self::Output {
let (success, status) = (response.status().is_success(), response.status().as_u16());
let headers = response.headers();
let body = response.body().as_ref();
::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
::tracing::debug!(request_id = ?::aws_http::request_id::RequestId::request_id(response));
if !success && status != 200 {
crate::protocol_serde::shape_list_objects::de_list_objects_http_error(
status, headers, body,
)
} else {
crate::protocol_serde::shape_list_objects::de_list_objects_http_response_with_props(
status, headers, body,
)
}
}
}
#[allow(unreachable_code, unused_variables)]
#[cfg(test)]
mod list_objects_request_test {
#[::tokio::test]
#[allow(unused_mut)]
async fn keys_with_whitespace_response() {
let expected_output = crate::operation::list_objects::ListObjectsOutput::builder()
.set_max_keys(::std::option::Option::Some(1000))
.set_is_truncated(::std::option::Option::Some(false))
.set_marker(::std::option::Option::Some("".to_owned()))
.set_name(::std::option::Option::Some("bucketname".to_owned()))
.set_prefix(::std::option::Option::Some("".to_owned()))
.set_contents(::std::option::Option::Some(vec![
crate::types::Object::builder()
.set_key(::std::option::Option::Some(" ".to_owned()))
.set_last_modified(::std::option::Option::Some(
::aws_smithy_types::DateTime::from_fractional_secs(1626452453, 0_f64),
))
.set_e_tag(::std::option::Option::Some("\"etag123\"".to_owned()))
.set_size(::std::option::Option::Some(0))
.set_owner(::std::option::Option::Some(
crate::types::Owner::builder()
.set_id(::std::option::Option::Some("owner".to_owned()))
.build(),
))
.set_storage_class(::std::option::Option::Some(
crate::types::ObjectStorageClass::from("STANDARD"),
))
.build(),
crate::types::Object::builder()
.set_key(::std::option::Option::Some(" a ".to_owned()))
.set_last_modified(::std::option::Option::Some(
::aws_smithy_types::DateTime::from_fractional_secs(1626451330, 0_f64),
))
.set_e_tag(::std::option::Option::Some("\"etag123\"".to_owned()))
.set_size(::std::option::Option::Some(0))
.set_owner(::std::option::Option::Some(
crate::types::Owner::builder()
.set_id(::std::option::Option::Some("owner".to_owned()))
.build(),
))
.set_storage_class(::std::option::Option::Some(
crate::types::ObjectStorageClass::from("STANDARD"),
))
.build(),
]))
.build();
let http_response = ::http::response::Builder::new()
.status(200)
.body(::aws_smithy_http::body::SdkBody::from("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n<ListBucketResult\n\txmlns=\"http://s3.amazonaws.com/doc/2006-03-01/\">\n\t<Name>bucketname</Name>\n\t<Prefix></Prefix>\n\t<Marker></Marker>\n\t<MaxKeys>1000</MaxKeys>\n\t<IsTruncated>false</IsTruncated>\n\t<Contents>\n\t\t<Key> </Key>\n\t\t<LastModified>2021-07-16T16:20:53.000Z</LastModified>\n\t\t<ETag>"etag123"</ETag>\n\t\t<Size>0</Size>\n\t\t<Owner>\n\t\t\t<ID>owner</ID>\n\t\t</Owner>\n\t\t<StorageClass>STANDARD</StorageClass>\n\t</Contents>\n\t<Contents>\n\t\t<Key> a </Key>\n\t\t<LastModified>2021-07-16T16:02:10.000Z</LastModified>\n\t\t<ETag>"etag123"</ETag>\n\t\t<Size>0</Size>\n\t\t<Owner>\n\t\t\t<ID>owner</ID>\n\t\t</Owner>\n\t\t<StorageClass>STANDARD</StorageClass>\n\t</Contents>\n</ListBucketResult>\n"))
.unwrap();
let mut op_response = ::aws_smithy_http::operation::Response::new(http_response);
use ::aws_smithy_http::response::ParseHttpResponse;
let parser = crate::operation::list_objects::ListObjects::new();
let parsed = parser.parse_unloaded(&mut op_response);
let parsed = parsed.unwrap_or_else(|| {
let (http_response, _) = op_response.into_parts();
let http_response = http_response.map(|body|::bytes::Bytes::copy_from_slice(body.bytes().unwrap()));
<crate::operation::list_objects::ListObjects as ::aws_smithy_http::response::ParseHttpResponse>::parse_loaded(&parser, &http_response)
});
let parsed = parsed.unwrap();
::pretty_assertions::assert_eq!(
parsed.is_truncated,
expected_output.is_truncated,
"Unexpected value for `is_truncated`"
);
::pretty_assertions::assert_eq!(
parsed.marker,
expected_output.marker,
"Unexpected value for `marker`"
);
::pretty_assertions::assert_eq!(
parsed.next_marker,
expected_output.next_marker,
"Unexpected value for `next_marker`"
);
::pretty_assertions::assert_eq!(
parsed.contents,
expected_output.contents,
"Unexpected value for `contents`"
);
::pretty_assertions::assert_eq!(
parsed.name,
expected_output.name,
"Unexpected value for `name`"
);
::pretty_assertions::assert_eq!(
parsed.prefix,
expected_output.prefix,
"Unexpected value for `prefix`"
);
::pretty_assertions::assert_eq!(
parsed.delimiter,
expected_output.delimiter,
"Unexpected value for `delimiter`"
);
::pretty_assertions::assert_eq!(
parsed.max_keys,
expected_output.max_keys,
"Unexpected value for `max_keys`"
);
::pretty_assertions::assert_eq!(
parsed.common_prefixes,
expected_output.common_prefixes,
"Unexpected value for `common_prefixes`"
);
::pretty_assertions::assert_eq!(
parsed.encoding_type,
expected_output.encoding_type,
"Unexpected value for `encoding_type`"
);
}
}
#[deprecated(
note = "Operation `*Error/*ErrorKind` types were combined into a single `*Error` enum. The `.kind` field on `*Error` no longer exists and isn't needed anymore (you can just match on the error directly since it's an enum now)."
)]
pub type ListObjectsErrorKind = ListObjectsError;
#[non_exhaustive]
#[derive(::std::fmt::Debug)]
pub enum ListObjectsError {
NoSuchBucket(crate::types::error::NoSuchBucket),
Unhandled(::aws_smithy_types::error::Unhandled),
}
impl ::aws_smithy_http::result::CreateUnhandledError for ListObjectsError {
fn create_unhandled_error(
source: ::std::boxed::Box<
dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static,
>,
meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
) -> Self {
Self::Unhandled({
let mut builder = ::aws_smithy_types::error::Unhandled::builder().source(source);
builder.set_meta(meta);
builder.build()
})
}
}
impl ::std::fmt::Display for ListObjectsError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match self {
Self::NoSuchBucket(_inner) => _inner.fmt(f),
Self::Unhandled(_inner) => _inner.fmt(f),
}
}
}
impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for ListObjectsError {
fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
match self {
Self::NoSuchBucket(_inner) => {
::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner)
}
Self::Unhandled(_inner) => {
::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner)
}
}
}
}
impl crate::s3_request_id::RequestIdExt for crate::operation::list_objects::ListObjectsError {
fn extended_request_id(&self) -> Option<&str> {
self.meta().extended_request_id()
}
}
impl ::aws_http::request_id::RequestId for crate::operation::list_objects::ListObjectsError {
fn request_id(&self) -> Option<&str> {
self.meta().request_id()
}
}
impl ::aws_smithy_types::retry::ProvideErrorKind for ListObjectsError {
fn code(&self) -> ::std::option::Option<&str> {
::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
}
fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
::std::option::Option::None
}
}
impl ListObjectsError {
pub fn unhandled(
err: impl ::std::convert::Into<
::std::boxed::Box<
dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static,
>,
>,
) -> Self {
Self::Unhandled(
::aws_smithy_types::error::Unhandled::builder()
.source(err)
.build(),
)
}
pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
Self::Unhandled(
::aws_smithy_types::error::Unhandled::builder()
.source(err.clone())
.meta(err)
.build(),
)
}
pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
match self {
Self::NoSuchBucket(e) => e.meta(),
Self::Unhandled(e) => e.meta(),
}
}
pub fn is_no_such_bucket(&self) -> bool {
matches!(self, Self::NoSuchBucket(_))
}
}
impl ::std::error::Error for ListObjectsError {
fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
match self {
Self::NoSuchBucket(_inner) => ::std::option::Option::Some(_inner),
Self::Unhandled(_inner) => ::std::option::Option::Some(_inner),
}
}
}
pub use crate::operation::list_objects::_list_objects_output::ListObjectsOutput;
pub use crate::operation::list_objects::_list_objects_input::ListObjectsInput;
mod _list_objects_input;
mod _list_objects_output;
pub mod builders;