1#[allow(clippy::unnecessary_wraps)]
3pub fn de_create_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::create_multipart_upload::CreateMultipartUploadOutput,
9 crate::operation::create_multipart_upload::CreateMultipartUploadError,
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::create_multipart_upload::CreateMultipartUploadError::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::create_multipart_upload::CreateMultipartUploadError::generic(generic))
18}
19
20#[allow(clippy::unnecessary_wraps)]
21pub fn de_create_multipart_upload_http_response(
22 _response_status: u16,
23 _response_headers: &::aws_smithy_runtime_api::http::Headers,
24 _response_body: &[u8],
25) -> std::result::Result<
26 crate::operation::create_multipart_upload::CreateMultipartUploadOutput,
27 crate::operation::create_multipart_upload::CreateMultipartUploadError,
28> {
29 Ok({
30 #[allow(unused_mut)]
31 let mut output = crate::operation::create_multipart_upload::builders::CreateMultipartUploadOutputBuilder::default();
32 output = crate::protocol_serde::shape_create_multipart_upload::de_create_multipart_upload(_response_body, output)
33 .map_err(crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled)?;
34 output = output.set_abort_date(
35 crate::protocol_serde::shape_create_multipart_upload_output::de_abort_date_header(_response_headers).map_err(|_| {
36 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
37 "Failed to parse AbortDate from header `x-amz-abort-date",
38 )
39 })?,
40 );
41 output = output.set_abort_rule_id(
42 crate::protocol_serde::shape_create_multipart_upload_output::de_abort_rule_id_header(_response_headers).map_err(|_| {
43 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
44 "Failed to parse AbortRuleId from header `x-amz-abort-rule-id",
45 )
46 })?,
47 );
48 output = output.set_bucket_key_enabled(
49 crate::protocol_serde::shape_create_multipart_upload_output::de_bucket_key_enabled_header(_response_headers).map_err(|_| {
50 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
51 "Failed to parse BucketKeyEnabled from header `x-amz-server-side-encryption-bucket-key-enabled",
52 )
53 })?,
54 );
55 output = output.set_checksum_algorithm(
56 crate::protocol_serde::shape_create_multipart_upload_output::de_checksum_algorithm_header(_response_headers).map_err(|_| {
57 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
58 "Failed to parse ChecksumAlgorithm from header `x-amz-checksum-algorithm",
59 )
60 })?,
61 );
62 output = output.set_checksum_type(
63 crate::protocol_serde::shape_create_multipart_upload_output::de_checksum_type_header(_response_headers).map_err(|_| {
64 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
65 "Failed to parse ChecksumType from header `x-amz-checksum-type",
66 )
67 })?,
68 );
69 output = output.set_request_charged(
70 crate::protocol_serde::shape_create_multipart_upload_output::de_request_charged_header(_response_headers).map_err(|_| {
71 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
72 "Failed to parse RequestCharged from header `x-amz-request-charged",
73 )
74 })?,
75 );
76 output = output.set_sse_customer_algorithm(
77 crate::protocol_serde::shape_create_multipart_upload_output::de_sse_customer_algorithm_header(_response_headers).map_err(|_| {
78 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
79 "Failed to parse SSECustomerAlgorithm from header `x-amz-server-side-encryption-customer-algorithm",
80 )
81 })?,
82 );
83 output = output.set_sse_customer_key_md5(
84 crate::protocol_serde::shape_create_multipart_upload_output::de_sse_customer_key_md5_header(_response_headers).map_err(|_| {
85 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
86 "Failed to parse SSECustomerKeyMD5 from header `x-amz-server-side-encryption-customer-key-MD5",
87 )
88 })?,
89 );
90 output = output.set_ssekms_encryption_context(
91 crate::protocol_serde::shape_create_multipart_upload_output::de_ssekms_encryption_context_header(_response_headers).map_err(|_| {
92 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
93 "Failed to parse SSEKMSEncryptionContext from header `x-amz-server-side-encryption-context",
94 )
95 })?,
96 );
97 output = output.set_ssekms_key_id(
98 crate::protocol_serde::shape_create_multipart_upload_output::de_ssekms_key_id_header(_response_headers).map_err(|_| {
99 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
100 "Failed to parse SSEKMSKeyId from header `x-amz-server-side-encryption-aws-kms-key-id",
101 )
102 })?,
103 );
104 output = output.set_server_side_encryption(
105 crate::protocol_serde::shape_create_multipart_upload_output::de_server_side_encryption_header(_response_headers).map_err(|_| {
106 crate::operation::create_multipart_upload::CreateMultipartUploadError::unhandled(
107 "Failed to parse ServerSideEncryption from header `x-amz-server-side-encryption",
108 )
109 })?,
110 );
111 output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
112 output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
113 output.build()
114 })
115}
116
117pub fn ser_create_multipart_upload_headers(
118 input: &crate::operation::create_multipart_upload::CreateMultipartUploadInput,
119 mut builder: ::http::request::Builder,
120) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
121 if let ::std::option::Option::Some(inner_1) = &input.acl {
122 let formatted_2 = inner_1.as_str();
123 let header_value = formatted_2;
124 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
125 ::aws_smithy_types::error::operation::BuildError::invalid_field(
126 "acl",
127 format!("`{}` cannot be used as a header value: {}", &header_value, err),
128 )
129 })?;
130 builder = builder.header("x-amz-acl", header_value);
131 }
132 if let ::std::option::Option::Some(inner_3) = &input.cache_control {
133 let formatted_4 = inner_3.as_str();
134 let header_value = formatted_4;
135 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
136 ::aws_smithy_types::error::operation::BuildError::invalid_field(
137 "cache_control",
138 format!("`{}` cannot be used as a header value: {}", &header_value, err),
139 )
140 })?;
141 builder = builder.header("Cache-Control", header_value);
142 }
143 if let ::std::option::Option::Some(inner_5) = &input.content_disposition {
144 let formatted_6 = inner_5.as_str();
145 let header_value = formatted_6;
146 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
147 ::aws_smithy_types::error::operation::BuildError::invalid_field(
148 "content_disposition",
149 format!("`{}` cannot be used as a header value: {}", &header_value, err),
150 )
151 })?;
152 builder = builder.header("Content-Disposition", header_value);
153 }
154 if let ::std::option::Option::Some(inner_7) = &input.content_encoding {
155 let formatted_8 = inner_7.as_str();
156 let header_value = formatted_8;
157 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
158 ::aws_smithy_types::error::operation::BuildError::invalid_field(
159 "content_encoding",
160 format!("`{}` cannot be used as a header value: {}", &header_value, err),
161 )
162 })?;
163 builder = builder.header("Content-Encoding", header_value);
164 }
165 if let ::std::option::Option::Some(inner_9) = &input.content_language {
166 let formatted_10 = inner_9.as_str();
167 let header_value = formatted_10;
168 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
169 ::aws_smithy_types::error::operation::BuildError::invalid_field(
170 "content_language",
171 format!("`{}` cannot be used as a header value: {}", &header_value, err),
172 )
173 })?;
174 builder = builder.header("Content-Language", header_value);
175 }
176 if let ::std::option::Option::Some(inner_11) = &input.content_type {
177 let formatted_12 = inner_11.as_str();
178 let header_value = formatted_12;
179 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
180 ::aws_smithy_types::error::operation::BuildError::invalid_field(
181 "content_type",
182 format!("`{}` cannot be used as a header value: {}", &header_value, err),
183 )
184 })?;
185 builder = builder.header("Content-Type", header_value);
186 }
187 if let ::std::option::Option::Some(inner_13) = &input.expires {
188 let formatted_14 = inner_13.fmt(::aws_smithy_types::date_time::Format::HttpDate)?;
189 let header_value = formatted_14;
190 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
191 ::aws_smithy_types::error::operation::BuildError::invalid_field(
192 "expires",
193 format!("`{}` cannot be used as a header value: {}", &header_value, err),
194 )
195 })?;
196 builder = builder.header("Expires", header_value);
197 }
198 if let ::std::option::Option::Some(inner_15) = &input.grant_full_control {
199 let formatted_16 = inner_15.as_str();
200 let header_value = formatted_16;
201 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
202 ::aws_smithy_types::error::operation::BuildError::invalid_field(
203 "grant_full_control",
204 format!("`{}` cannot be used as a header value: {}", &header_value, err),
205 )
206 })?;
207 builder = builder.header("x-amz-grant-full-control", header_value);
208 }
209 if let ::std::option::Option::Some(inner_17) = &input.grant_read {
210 let formatted_18 = inner_17.as_str();
211 let header_value = formatted_18;
212 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
213 ::aws_smithy_types::error::operation::BuildError::invalid_field(
214 "grant_read",
215 format!("`{}` cannot be used as a header value: {}", &header_value, err),
216 )
217 })?;
218 builder = builder.header("x-amz-grant-read", header_value);
219 }
220 if let ::std::option::Option::Some(inner_19) = &input.grant_read_acp {
221 let formatted_20 = inner_19.as_str();
222 let header_value = formatted_20;
223 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
224 ::aws_smithy_types::error::operation::BuildError::invalid_field(
225 "grant_read_acp",
226 format!("`{}` cannot be used as a header value: {}", &header_value, err),
227 )
228 })?;
229 builder = builder.header("x-amz-grant-read-acp", header_value);
230 }
231 if let ::std::option::Option::Some(inner_21) = &input.grant_write_acp {
232 let formatted_22 = inner_21.as_str();
233 let header_value = formatted_22;
234 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
235 ::aws_smithy_types::error::operation::BuildError::invalid_field(
236 "grant_write_acp",
237 format!("`{}` cannot be used as a header value: {}", &header_value, err),
238 )
239 })?;
240 builder = builder.header("x-amz-grant-write-acp", header_value);
241 }
242 if let ::std::option::Option::Some(inner_23) = &input.server_side_encryption {
243 let formatted_24 = inner_23.as_str();
244 let header_value = formatted_24;
245 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
246 ::aws_smithy_types::error::operation::BuildError::invalid_field(
247 "server_side_encryption",
248 format!("`{}` cannot be used as a header value: {}", &header_value, err),
249 )
250 })?;
251 builder = builder.header("x-amz-server-side-encryption", header_value);
252 }
253 if let ::std::option::Option::Some(inner_25) = &input.storage_class {
254 let formatted_26 = inner_25.as_str();
255 let header_value = formatted_26;
256 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
257 ::aws_smithy_types::error::operation::BuildError::invalid_field(
258 "storage_class",
259 format!("`{}` cannot be used as a header value: {}", &header_value, err),
260 )
261 })?;
262 builder = builder.header("x-amz-storage-class", header_value);
263 }
264 if let ::std::option::Option::Some(inner_27) = &input.website_redirect_location {
265 let formatted_28 = inner_27.as_str();
266 let header_value = formatted_28;
267 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
268 ::aws_smithy_types::error::operation::BuildError::invalid_field(
269 "website_redirect_location",
270 format!("`{}` cannot be used as a header value: {}", &header_value, err),
271 )
272 })?;
273 builder = builder.header("x-amz-website-redirect-location", header_value);
274 }
275 if let ::std::option::Option::Some(inner_29) = &input.sse_customer_algorithm {
276 let formatted_30 = inner_29.as_str();
277 let header_value = formatted_30;
278 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
279 ::aws_smithy_types::error::operation::BuildError::invalid_field(
280 "sse_customer_algorithm",
281 format!("`{}` cannot be used as a header value: {}", &header_value, err),
282 )
283 })?;
284 builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
285 }
286 if let ::std::option::Option::Some(inner_31) = &input.sse_customer_key {
287 let formatted_32 = inner_31.as_str();
288 let header_value = formatted_32;
289 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
290 ::aws_smithy_types::error::operation::BuildError::invalid_field(
291 "sse_customer_key",
292 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
293 )
294 })?;
295 builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
296 }
297 if let ::std::option::Option::Some(inner_33) = &input.sse_customer_key_md5 {
298 let formatted_34 = inner_33.as_str();
299 let header_value = formatted_34;
300 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
301 ::aws_smithy_types::error::operation::BuildError::invalid_field(
302 "sse_customer_key_md5",
303 format!("`{}` cannot be used as a header value: {}", &header_value, err),
304 )
305 })?;
306 builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
307 }
308 if let ::std::option::Option::Some(inner_35) = &input.ssekms_key_id {
309 let formatted_36 = inner_35.as_str();
310 let header_value = formatted_36;
311 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
312 ::aws_smithy_types::error::operation::BuildError::invalid_field(
313 "ssekms_key_id",
314 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
315 )
316 })?;
317 builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
318 }
319 if let ::std::option::Option::Some(inner_37) = &input.ssekms_encryption_context {
320 let formatted_38 = inner_37.as_str();
321 let header_value = formatted_38;
322 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
323 ::aws_smithy_types::error::operation::BuildError::invalid_field(
324 "ssekms_encryption_context",
325 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
326 )
327 })?;
328 builder = builder.header("x-amz-server-side-encryption-context", header_value);
329 }
330 if let ::std::option::Option::Some(inner_39) = &input.bucket_key_enabled {
331 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_39);
332 let formatted_40 = encoder.encode();
333 let header_value = formatted_40;
334 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
335 ::aws_smithy_types::error::operation::BuildError::invalid_field(
336 "bucket_key_enabled",
337 format!("`{}` cannot be used as a header value: {}", &header_value, err),
338 )
339 })?;
340 builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
341 }
342 if let ::std::option::Option::Some(inner_41) = &input.request_payer {
343 let formatted_42 = inner_41.as_str();
344 let header_value = formatted_42;
345 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
346 ::aws_smithy_types::error::operation::BuildError::invalid_field(
347 "request_payer",
348 format!("`{}` cannot be used as a header value: {}", &header_value, err),
349 )
350 })?;
351 builder = builder.header("x-amz-request-payer", header_value);
352 }
353 if let ::std::option::Option::Some(inner_43) = &input.tagging {
354 let formatted_44 = inner_43.as_str();
355 let header_value = formatted_44;
356 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
357 ::aws_smithy_types::error::operation::BuildError::invalid_field(
358 "tagging",
359 format!("`{}` cannot be used as a header value: {}", &header_value, err),
360 )
361 })?;
362 builder = builder.header("x-amz-tagging", header_value);
363 }
364 if let ::std::option::Option::Some(inner_45) = &input.object_lock_mode {
365 let formatted_46 = inner_45.as_str();
366 let header_value = formatted_46;
367 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
368 ::aws_smithy_types::error::operation::BuildError::invalid_field(
369 "object_lock_mode",
370 format!("`{}` cannot be used as a header value: {}", &header_value, err),
371 )
372 })?;
373 builder = builder.header("x-amz-object-lock-mode", header_value);
374 }
375 if let ::std::option::Option::Some(inner_47) = &input.object_lock_retain_until_date {
376 let formatted_48 = inner_47.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
377 let header_value = formatted_48;
378 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
379 ::aws_smithy_types::error::operation::BuildError::invalid_field(
380 "object_lock_retain_until_date",
381 format!("`{}` cannot be used as a header value: {}", &header_value, err),
382 )
383 })?;
384 builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
385 }
386 if let ::std::option::Option::Some(inner_49) = &input.object_lock_legal_hold_status {
387 let formatted_50 = inner_49.as_str();
388 let header_value = formatted_50;
389 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
390 ::aws_smithy_types::error::operation::BuildError::invalid_field(
391 "object_lock_legal_hold_status",
392 format!("`{}` cannot be used as a header value: {}", &header_value, err),
393 )
394 })?;
395 builder = builder.header("x-amz-object-lock-legal-hold", header_value);
396 }
397 if let ::std::option::Option::Some(inner_51) = &input.expected_bucket_owner {
398 let formatted_52 = inner_51.as_str();
399 let header_value = formatted_52;
400 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
401 ::aws_smithy_types::error::operation::BuildError::invalid_field(
402 "expected_bucket_owner",
403 format!("`{}` cannot be used as a header value: {}", &header_value, err),
404 )
405 })?;
406 builder = builder.header("x-amz-expected-bucket-owner", header_value);
407 }
408 if let ::std::option::Option::Some(inner_53) = &input.checksum_algorithm {
409 let formatted_54 = inner_53.as_str();
410 let header_value = formatted_54;
411 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
412 ::aws_smithy_types::error::operation::BuildError::invalid_field(
413 "checksum_algorithm",
414 format!("`{}` cannot be used as a header value: {}", &header_value, err),
415 )
416 })?;
417 builder = builder.header("x-amz-checksum-algorithm", header_value);
418 }
419 if let ::std::option::Option::Some(inner_55) = &input.checksum_type {
420 let formatted_56 = inner_55.as_str();
421 let header_value = formatted_56;
422 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
423 ::aws_smithy_types::error::operation::BuildError::invalid_field(
424 "checksum_type",
425 format!("`{}` cannot be used as a header value: {}", &header_value, err),
426 )
427 })?;
428 builder = builder.header("x-amz-checksum-type", header_value);
429 }
430 if let ::std::option::Option::Some(inner_57) = &input.metadata {
431 {
432 for (k, v) in inner_57 {
433 use std::str::FromStr;
434 let header_name = http::header::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
435 ::aws_smithy_types::error::operation::BuildError::invalid_field(
436 "metadata",
437 format!("`{k}` cannot be used as a header name: {err}"),
438 )
439 })?;
440 let header_value = v.as_str();
441 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
442 ::aws_smithy_types::error::operation::BuildError::invalid_field(
443 "metadata",
444 format!("`{}` cannot be used as a header value: {}", v, err),
445 )
446 })?;
447 builder = builder.header(header_name, header_value);
448 }
449 }
450 }
451 Ok(builder)
452}
453
454#[allow(unused_mut)]
455pub fn de_create_multipart_upload(
456 inp: &[u8],
457 mut builder: crate::operation::create_multipart_upload::builders::CreateMultipartUploadOutputBuilder,
458) -> std::result::Result<
459 crate::operation::create_multipart_upload::builders::CreateMultipartUploadOutputBuilder,
460 ::aws_smithy_xml::decode::XmlDecodeError,
461> {
462 let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
463
464 #[allow(unused_mut)]
465 let mut decoder = doc.root_element()?;
466 #[allow(unused_variables)]
467 let start_el = decoder.start_el();
468 if !start_el.matches("InitiateMultipartUploadResult") {
469 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
470 "encountered invalid XML root: expected InitiateMultipartUploadResult but got {:?}. This is likely a bug in the SDK.",
471 start_el
472 )));
473 }
474 while let Some(mut tag) = decoder.next_tag() {
475 match tag.start_el() {
476 s if s.matches("UploadId") => {
477 let var_58 =
478 Some(
479 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
480 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
481 .into()
482 )
483 ?
484 )
485 ;
486 builder = builder.set_upload_id(var_58);
487 }
488 ,
489 s if s.matches("Bucket") => {
490 let var_59 =
491 Some(
492 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
493 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
494 .into()
495 )
496 ?
497 )
498 ;
499 builder = builder.set_bucket(var_59);
500 }
501 ,
502 s if s.matches("Key") => {
503 let var_60 =
504 Some(
505 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
506 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
507 .into()
508 )
509 ?
510 )
511 ;
512 builder = builder.set_key(var_60);
513 }
514 ,
515 _ => {}
516 }
517 }
518 Ok(builder)
519}