aws_sdk_s3/protocol_serde/
shape_create_session.rs
1#[allow(clippy::unnecessary_wraps)]
3pub fn de_create_session_http_error(
4 _response_status: u16,
5 _response_headers: &::aws_smithy_runtime_api::http::Headers,
6 _response_body: &[u8],
7) -> std::result::Result<crate::operation::create_session::CreateSessionOutput, crate::operation::create_session::CreateSessionError> {
8 #[allow(unused_mut)]
9 let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
10 .map_err(crate::operation::create_session::CreateSessionError::unhandled)?;
11 generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
12 generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
13 let generic = generic_builder.build();
14 let error_code = match generic.code() {
15 Some(code) => code,
16 None => return Err(crate::operation::create_session::CreateSessionError::unhandled(generic)),
17 };
18
19 let _error_message = generic.message().map(|msg| msg.to_owned());
20 Err(match error_code {
21 "NoSuchBucket" => crate::operation::create_session::CreateSessionError::NoSuchBucket({
22 #[allow(unused_mut)]
23 let mut tmp = {
24 #[allow(unused_mut)]
25 let mut output = crate::types::error::builders::NoSuchBucketBuilder::default();
26 output = crate::protocol_serde::shape_no_such_bucket::de_no_such_bucket_xml_err(_response_body, output)
27 .map_err(crate::operation::create_session::CreateSessionError::unhandled)?;
28 let output = output.meta(generic);
29 output.build()
30 };
31 if tmp.message.is_none() {
32 tmp.message = _error_message;
33 }
34 tmp
35 }),
36 _ => crate::operation::create_session::CreateSessionError::generic(generic),
37 })
38}
39
40#[allow(clippy::unnecessary_wraps)]
41pub fn de_create_session_http_response(
42 _response_status: u16,
43 _response_headers: &::aws_smithy_runtime_api::http::Headers,
44 _response_body: &[u8],
45) -> std::result::Result<crate::operation::create_session::CreateSessionOutput, crate::operation::create_session::CreateSessionError> {
46 Ok({
47 #[allow(unused_mut)]
48 let mut output = crate::operation::create_session::builders::CreateSessionOutputBuilder::default();
49 output = crate::protocol_serde::shape_create_session::de_create_session(_response_body, output)
50 .map_err(crate::operation::create_session::CreateSessionError::unhandled)?;
51 output = output.set_bucket_key_enabled(
52 crate::protocol_serde::shape_create_session_output::de_bucket_key_enabled_header(_response_headers).map_err(|_| {
53 crate::operation::create_session::CreateSessionError::unhandled(
54 "Failed to parse BucketKeyEnabled from header `x-amz-server-side-encryption-bucket-key-enabled",
55 )
56 })?,
57 );
58 output = output.set_ssekms_encryption_context(
59 crate::protocol_serde::shape_create_session_output::de_ssekms_encryption_context_header(_response_headers).map_err(|_| {
60 crate::operation::create_session::CreateSessionError::unhandled(
61 "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
62 )
63 })?,
64 );
65 output = output.set_ssekms_key_id(
66 crate::protocol_serde::shape_create_session_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
67 crate::operation::create_session::CreateSessionError::unhandled(
68 "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
69 )
70 })?,
71 );
72 output = output.set_server_side_encryption(
73 crate::protocol_serde::shape_create_session_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
74 crate::operation::create_session::CreateSessionError::unhandled(
75 "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
76 )
77 })?,
78 );
79 output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
80 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
81 crate::serde_util::create_session_output_output_correct_errors(output).build()
82 })
83}
84
85pub fn ser_create_session_headers(
86 input: &crate::operation::create_session::CreateSessionInput,
87 mut builder: ::http::request::Builder,
88) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
89 if let ::std::option::Option::Some(inner_1) = &input.session_mode {
90 let formatted_2 = inner_1.as_str();
91 let header_value = formatted_2;
92 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
93 ::aws_smithy_types::error::operation::BuildError::invalid_field(
94 "session_mode",
95 format!("`{}` cannot be used as a header value: {}", &header_value, err),
96 )
97 })?;
98 builder = builder.header("x-amz-create-session-mode", header_value);
99 }
100 if let ::std::option::Option::Some(inner_3) = &input.server_side_encryption {
101 let formatted_4 = inner_3.as_str();
102 let header_value = formatted_4;
103 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
104 ::aws_smithy_types::error::operation::BuildError::invalid_field(
105 "server_side_encryption",
106 format!("`{}` cannot be used as a header value: {}", &header_value, err),
107 )
108 })?;
109 builder = builder.header("x-amz-server-side-encryption", header_value);
110 }
111 if let ::std::option::Option::Some(inner_5) = &input.ssekms_key_id {
112 let formatted_6 = inner_5.as_str();
113 let header_value = formatted_6;
114 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
115 ::aws_smithy_types::error::operation::BuildError::invalid_field(
116 "ssekms_key_id",
117 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
118 )
119 })?;
120 builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
121 }
122 if let ::std::option::Option::Some(inner_7) = &input.ssekms_encryption_context {
123 let formatted_8 = inner_7.as_str();
124 let header_value = formatted_8;
125 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
126 ::aws_smithy_types::error::operation::BuildError::invalid_field(
127 "ssekms_encryption_context",
128 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
129 )
130 })?;
131 builder = builder.header("x-amz-server-side-encryption-context", header_value);
132 }
133 if let ::std::option::Option::Some(inner_9) = &input.bucket_key_enabled {
134 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_9);
135 let formatted_10 = encoder.encode();
136 let header_value = formatted_10;
137 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
138 ::aws_smithy_types::error::operation::BuildError::invalid_field(
139 "bucket_key_enabled",
140 format!("`{}` cannot be used as a header value: {}", &header_value, err),
141 )
142 })?;
143 builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
144 }
145 Ok(builder)
146}
147
148#[allow(unused_mut)]
149pub fn de_create_session(
150 inp: &[u8],
151 mut builder: crate::operation::create_session::builders::CreateSessionOutputBuilder,
152) -> std::result::Result<crate::operation::create_session::builders::CreateSessionOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
153 let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
154
155 #[allow(unused_mut)]
156 let mut decoder = doc.root_element()?;
157 #[allow(unused_variables)]
158 let start_el = decoder.start_el();
159 while let Some(mut tag) = decoder.next_tag() {
160 match tag.start_el() {
161 s if s.matches("Credentials") => {
162 let var_11 =
163 Some(
164 crate::protocol_serde::shape_session_credentials::de_session_credentials(&mut tag)
165 ?
166 )
167 ;
168 builder = builder.set_credentials(var_11);
169 }
170 ,
171 _ => {}
172 }
173 }
174 Ok(builder)
175}