aws_sdk_s3/protocol_serde/
shape_complete_multipart_upload.rs1#[allow(clippy::unnecessary_wraps)]
3pub fn de_complete_multipart_upload_http_error(
4 _response_status: u16,
5 _response_headers: &::aws_smithy_runtime_api::http::Headers,
6 _response_body: &[u8],
7) -> std::result::Result<
8 crate::operation::complete_multipart_upload::CompleteMultipartUploadOutput,
9 crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
10> {
11 #[allow(unused_mut)]
12 let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
13 .map_err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled)?;
14 generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
15 generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
16 let generic = generic_builder.build();
17 Err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::generic(
18 generic,
19 ))
20}
21
22#[allow(clippy::unnecessary_wraps)]
23pub fn de_complete_multipart_upload_http_response(
24 _response_status: u16,
25 _response_headers: &::aws_smithy_runtime_api::http::Headers,
26 _response_body: &[u8],
27) -> std::result::Result<
28 crate::operation::complete_multipart_upload::CompleteMultipartUploadOutput,
29 crate::operation::complete_multipart_upload::CompleteMultipartUploadError,
30> {
31 Ok({
32 #[allow(unused_mut)]
33 let mut output = crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder::default();
34 output = crate::protocol_serde::shape_complete_multipart_upload::de_complete_multipart_upload(_response_body, output)
35 .map_err(crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled)?;
36 output = output.set_bucket_key_enabled(
37 crate::protocol_serde::shape_complete_multipart_upload_output::de_bucket_key_enabled_header(_response_headers).map_err(|_| {
38 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
39 "Failed to parse BucketKeyEnabled from header `x-amz-server-side-encryption-bucket-key-enabled",
40 )
41 })?,
42 );
43 output = output.set_expiration(
44 crate::protocol_serde::shape_complete_multipart_upload_output::de_expiration_header(_response_headers).map_err(|_| {
45 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
46 "Failed to parse Expiration from header `x-amz-expiration",
47 )
48 })?,
49 );
50 output = output.set_request_charged(
51 crate::protocol_serde::shape_complete_multipart_upload_output::de_request_charged_header(_response_headers).map_err(|_| {
52 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
53 "Failed to parse RequestCharged from header `x-amz-request-charged",
54 )
55 })?,
56 );
57 output = output.set_ssekms_key_id(
58 crate::protocol_serde::shape_complete_multipart_upload_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
59 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
60 "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
61 )
62 })?,
63 );
64 output = output.set_server_side_encryption(
65 crate::protocol_serde::shape_complete_multipart_upload_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
66 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
67 "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
68 )
69 })?,
70 );
71 output = output.set_version_id(
72 crate::protocol_serde::shape_complete_multipart_upload_output::de_version_id_header(_response_headers).map_err(|_| {
73 crate::operation::complete_multipart_upload::CompleteMultipartUploadError::unhandled(
74 "Failed to parse VersionId from header `x-amz-version-id",
75 )
76 })?,
77 );
78 output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
79 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
80 output.build()
81 })
82}
83
84pub fn ser_complete_multipart_upload_headers(
85 input: &crate::operation::complete_multipart_upload::CompleteMultipartUploadInput,
86 mut builder: ::http::request::Builder,
87) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
88 if let ::std::option::Option::Some(inner_1) = &input.checksum_crc32 {
89 let formatted_2 = inner_1.as_str();
90 let header_value = formatted_2;
91 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
92 ::aws_smithy_types::error::operation::BuildError::invalid_field(
93 "checksum_crc32",
94 format!("`{}` cannot be used as a header value: {}", &header_value, err),
95 )
96 })?;
97 builder = builder.header("x-amz-checksum-crc32", header_value);
98 }
99 if let ::std::option::Option::Some(inner_3) = &input.checksum_crc32_c {
100 let formatted_4 = inner_3.as_str();
101 let header_value = formatted_4;
102 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
103 ::aws_smithy_types::error::operation::BuildError::invalid_field(
104 "checksum_crc32_c",
105 format!("`{}` cannot be used as a header value: {}", &header_value, err),
106 )
107 })?;
108 builder = builder.header("x-amz-checksum-crc32c", header_value);
109 }
110 if let ::std::option::Option::Some(inner_5) = &input.checksum_sha1 {
111 let formatted_6 = inner_5.as_str();
112 let header_value = formatted_6;
113 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
114 ::aws_smithy_types::error::operation::BuildError::invalid_field(
115 "checksum_sha1",
116 format!("`{}` cannot be used as a header value: {}", &header_value, err),
117 )
118 })?;
119 builder = builder.header("x-amz-checksum-sha1", header_value);
120 }
121 if let ::std::option::Option::Some(inner_7) = &input.checksum_sha256 {
122 let formatted_8 = inner_7.as_str();
123 let header_value = formatted_8;
124 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
125 ::aws_smithy_types::error::operation::BuildError::invalid_field(
126 "checksum_sha256",
127 format!("`{}` cannot be used as a header value: {}", &header_value, err),
128 )
129 })?;
130 builder = builder.header("x-amz-checksum-sha256", header_value);
131 }
132 if let ::std::option::Option::Some(inner_9) = &input.request_payer {
133 let formatted_10 = inner_9.as_str();
134 let header_value = formatted_10;
135 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
136 ::aws_smithy_types::error::operation::BuildError::invalid_field(
137 "request_payer",
138 format!("`{}` cannot be used as a header value: {}", &header_value, err),
139 )
140 })?;
141 builder = builder.header("x-amz-request-payer", header_value);
142 }
143 if let ::std::option::Option::Some(inner_11) = &input.expected_bucket_owner {
144 let formatted_12 = inner_11.as_str();
145 let header_value = formatted_12;
146 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
147 ::aws_smithy_types::error::operation::BuildError::invalid_field(
148 "expected_bucket_owner",
149 format!("`{}` cannot be used as a header value: {}", &header_value, err),
150 )
151 })?;
152 builder = builder.header("x-amz-expected-bucket-owner", header_value);
153 }
154 if let ::std::option::Option::Some(inner_13) = &input.if_match {
155 let formatted_14 = inner_13.as_str();
156 let header_value = formatted_14;
157 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
158 ::aws_smithy_types::error::operation::BuildError::invalid_field(
159 "if_match",
160 format!("`{}` cannot be used as a header value: {}", &header_value, err),
161 )
162 })?;
163 builder = builder.header("If-Match", header_value);
164 }
165 if let ::std::option::Option::Some(inner_15) = &input.if_none_match {
166 let formatted_16 = inner_15.as_str();
167 let header_value = formatted_16;
168 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
169 ::aws_smithy_types::error::operation::BuildError::invalid_field(
170 "if_none_match",
171 format!("`{}` cannot be used as a header value: {}", &header_value, err),
172 )
173 })?;
174 builder = builder.header("If-None-Match", header_value);
175 }
176 if let ::std::option::Option::Some(inner_17) = &input.sse_customer_algorithm {
177 let formatted_18 = inner_17.as_str();
178 let header_value = formatted_18;
179 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
180 ::aws_smithy_types::error::operation::BuildError::invalid_field(
181 "sse_customer_algorithm",
182 format!("`{}` cannot be used as a header value: {}", &header_value, err),
183 )
184 })?;
185 builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
186 }
187 if let ::std::option::Option::Some(inner_19) = &input.sse_customer_key {
188 let formatted_20 = inner_19.as_str();
189 let header_value = formatted_20;
190 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
191 ::aws_smithy_types::error::operation::BuildError::invalid_field(
192 "sse_customer_key",
193 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
194 )
195 })?;
196 builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
197 }
198 if let ::std::option::Option::Some(inner_21) = &input.sse_customer_key_md5 {
199 let formatted_22 = inner_21.as_str();
200 let header_value = formatted_22;
201 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
202 ::aws_smithy_types::error::operation::BuildError::invalid_field(
203 "sse_customer_key_md5",
204 format!("`{}` cannot be used as a header value: {}", &header_value, err),
205 )
206 })?;
207 builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
208 }
209 Ok(builder)
210}
211
212#[allow(unused_mut)]
213pub fn de_complete_multipart_upload(
214 inp: &[u8],
215 mut builder: crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder,
216) -> Result<crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
217 let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
218
219 #[allow(unused_mut)]
220 let mut decoder = doc.root_element()?;
221 #[allow(unused_variables)]
222 let start_el = decoder.start_el();
223 if !start_el.matches("CompleteMultipartUploadResult") {
224 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
225 "encountered invalid XML root: expected CompleteMultipartUploadResult but got {:?}. This is likely a bug in the SDK.",
226 start_el
227 )));
228 }
229 while let Some(mut tag) = decoder.next_tag() {
230 match tag.start_el() {
231 s if s.matches("ChecksumSHA1") => {
232 let var_23 =
233 Some(
234 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
235 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
236 .into()
237 )
238 ?
239 )
240 ;
241 builder = builder.set_checksum_sha1(var_23);
242 }
243 ,
244 s if s.matches("ChecksumSHA256") => {
245 let var_24 =
246 Some(
247 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
248 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
249 .into()
250 )
251 ?
252 )
253 ;
254 builder = builder.set_checksum_sha256(var_24);
255 }
256 ,
257 s if s.matches("Bucket") => {
258 let var_25 =
259 Some(
260 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
261 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
262 .into()
263 )
264 ?
265 )
266 ;
267 builder = builder.set_bucket(var_25);
268 }
269 ,
270 s if s.matches("ETag") => {
271 let var_26 =
272 Some(
273 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
274 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
275 .into()
276 )
277 ?
278 )
279 ;
280 builder = builder.set_e_tag(var_26);
281 }
282 ,
283 s if s.matches("ChecksumCRC32C") => {
284 let var_27 =
285 Some(
286 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
287 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
288 .into()
289 )
290 ?
291 )
292 ;
293 builder = builder.set_checksum_crc32_c(var_27);
294 }
295 ,
296 s if s.matches("ChecksumCRC32") => {
297 let var_28 =
298 Some(
299 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
300 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
301 .into()
302 )
303 ?
304 )
305 ;
306 builder = builder.set_checksum_crc32(var_28);
307 }
308 ,
309 s if s.matches("Key") => {
310 let var_29 =
311 Some(
312 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
313 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
314 .into()
315 )
316 ?
317 )
318 ;
319 builder = builder.set_key(var_29);
320 }
321 ,
322 s if s.matches("Location") => {
323 let var_30 =
324 Some(
325 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
326 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
327 .into()
328 )
329 ?
330 )
331 ;
332 builder = builder.set_location(var_30);
333 }
334 ,
335 _ => {}
336 }
337 }
338 Ok(builder)
339}