aws_sdk_s3/protocol_serde/
shape_complete_multipart_upload.rs
1#[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_crc64_nvme {
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_crc64_nvme",
116 format!("`{}` cannot be used as a header value: {}", &header_value, err),
117 )
118 })?;
119 builder = builder.header("x-amz-checksum-crc64nvme", header_value);
120 }
121 if let ::std::option::Option::Some(inner_7) = &input.checksum_sha1 {
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_sha1",
127 format!("`{}` cannot be used as a header value: {}", &header_value, err),
128 )
129 })?;
130 builder = builder.header("x-amz-checksum-sha1", header_value);
131 }
132 if let ::std::option::Option::Some(inner_9) = &input.checksum_sha256 {
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 "checksum_sha256",
138 format!("`{}` cannot be used as a header value: {}", &header_value, err),
139 )
140 })?;
141 builder = builder.header("x-amz-checksum-sha256", header_value);
142 }
143 if let ::std::option::Option::Some(inner_11) = &input.checksum_type {
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 "checksum_type",
149 format!("`{}` cannot be used as a header value: {}", &header_value, err),
150 )
151 })?;
152 builder = builder.header("x-amz-checksum-type", header_value);
153 }
154 if let ::std::option::Option::Some(inner_13) = &input.mpu_object_size {
155 let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_13);
156 let formatted_14 = encoder.encode();
157 let header_value = formatted_14;
158 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
159 ::aws_smithy_types::error::operation::BuildError::invalid_field(
160 "mpu_object_size",
161 format!("`{}` cannot be used as a header value: {}", &header_value, err),
162 )
163 })?;
164 builder = builder.header("x-amz-mp-object-size", header_value);
165 }
166 if let ::std::option::Option::Some(inner_15) = &input.request_payer {
167 let formatted_16 = inner_15.as_str();
168 let header_value = formatted_16;
169 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
170 ::aws_smithy_types::error::operation::BuildError::invalid_field(
171 "request_payer",
172 format!("`{}` cannot be used as a header value: {}", &header_value, err),
173 )
174 })?;
175 builder = builder.header("x-amz-request-payer", header_value);
176 }
177 if let ::std::option::Option::Some(inner_17) = &input.expected_bucket_owner {
178 let formatted_18 = inner_17.as_str();
179 let header_value = formatted_18;
180 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
181 ::aws_smithy_types::error::operation::BuildError::invalid_field(
182 "expected_bucket_owner",
183 format!("`{}` cannot be used as a header value: {}", &header_value, err),
184 )
185 })?;
186 builder = builder.header("x-amz-expected-bucket-owner", header_value);
187 }
188 if let ::std::option::Option::Some(inner_19) = &input.if_match {
189 let formatted_20 = inner_19.as_str();
190 let header_value = formatted_20;
191 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
192 ::aws_smithy_types::error::operation::BuildError::invalid_field(
193 "if_match",
194 format!("`{}` cannot be used as a header value: {}", &header_value, err),
195 )
196 })?;
197 builder = builder.header("If-Match", header_value);
198 }
199 if let ::std::option::Option::Some(inner_21) = &input.if_none_match {
200 let formatted_22 = inner_21.as_str();
201 let header_value = formatted_22;
202 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
203 ::aws_smithy_types::error::operation::BuildError::invalid_field(
204 "if_none_match",
205 format!("`{}` cannot be used as a header value: {}", &header_value, err),
206 )
207 })?;
208 builder = builder.header("If-None-Match", header_value);
209 }
210 if let ::std::option::Option::Some(inner_23) = &input.sse_customer_algorithm {
211 let formatted_24 = inner_23.as_str();
212 let header_value = formatted_24;
213 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
214 ::aws_smithy_types::error::operation::BuildError::invalid_field(
215 "sse_customer_algorithm",
216 format!("`{}` cannot be used as a header value: {}", &header_value, err),
217 )
218 })?;
219 builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
220 }
221 if let ::std::option::Option::Some(inner_25) = &input.sse_customer_key {
222 let formatted_26 = inner_25.as_str();
223 let header_value = formatted_26;
224 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
225 ::aws_smithy_types::error::operation::BuildError::invalid_field(
226 "sse_customer_key",
227 format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
228 )
229 })?;
230 builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
231 }
232 if let ::std::option::Option::Some(inner_27) = &input.sse_customer_key_md5 {
233 let formatted_28 = inner_27.as_str();
234 let header_value = formatted_28;
235 let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
236 ::aws_smithy_types::error::operation::BuildError::invalid_field(
237 "sse_customer_key_md5",
238 format!("`{}` cannot be used as a header value: {}", &header_value, err),
239 )
240 })?;
241 builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
242 }
243 Ok(builder)
244}
245
246#[allow(unused_mut)]
247pub fn de_complete_multipart_upload(
248 inp: &[u8],
249 mut builder: crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder,
250) -> std::result::Result<
251 crate::operation::complete_multipart_upload::builders::CompleteMultipartUploadOutputBuilder,
252 ::aws_smithy_xml::decode::XmlDecodeError,
253> {
254 let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
255
256 #[allow(unused_mut)]
257 let mut decoder = doc.root_element()?;
258 #[allow(unused_variables)]
259 let start_el = decoder.start_el();
260 if !start_el.matches("CompleteMultipartUploadResult") {
261 return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
262 "encountered invalid XML root: expected CompleteMultipartUploadResult but got {:?}. This is likely a bug in the SDK.",
263 start_el
264 )));
265 }
266 while let Some(mut tag) = decoder.next_tag() {
267 match tag.start_el() {
268 s if s.matches("ChecksumSHA1") => {
269 let var_29 =
270 Some(
271 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
272 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
273 .into()
274 )
275 ?
276 )
277 ;
278 builder = builder.set_checksum_sha1(var_29);
279 }
280 ,
281 s if s.matches("ChecksumType") => {
282 let var_30 =
283 Some(
284 Result::<crate::types::ChecksumType, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
285 crate::types::ChecksumType::from(
286 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
287 )
288 )
289 ?
290 )
291 ;
292 builder = builder.set_checksum_type(var_30);
293 }
294 ,
295 s if s.matches("ChecksumSHA256") => {
296 let var_31 =
297 Some(
298 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
299 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
300 .into()
301 )
302 ?
303 )
304 ;
305 builder = builder.set_checksum_sha256(var_31);
306 }
307 ,
308 s if s.matches("ChecksumCRC64NVME") => {
309 let var_32 =
310 Some(
311 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
312 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
313 .into()
314 )
315 ?
316 )
317 ;
318 builder = builder.set_checksum_crc64_nvme(var_32);
319 }
320 ,
321 s if s.matches("Bucket") => {
322 let var_33 =
323 Some(
324 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
325 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
326 .into()
327 )
328 ?
329 )
330 ;
331 builder = builder.set_bucket(var_33);
332 }
333 ,
334 s if s.matches("ETag") => {
335 let var_34 =
336 Some(
337 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
338 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
339 .into()
340 )
341 ?
342 )
343 ;
344 builder = builder.set_e_tag(var_34);
345 }
346 ,
347 s if s.matches("ChecksumCRC32C") => {
348 let var_35 =
349 Some(
350 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
351 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
352 .into()
353 )
354 ?
355 )
356 ;
357 builder = builder.set_checksum_crc32_c(var_35);
358 }
359 ,
360 s if s.matches("ChecksumCRC32") => {
361 let var_36 =
362 Some(
363 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
364 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
365 .into()
366 )
367 ?
368 )
369 ;
370 builder = builder.set_checksum_crc32(var_36);
371 }
372 ,
373 s if s.matches("Key") => {
374 let var_37 =
375 Some(
376 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
377 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
378 .into()
379 )
380 ?
381 )
382 ;
383 builder = builder.set_key(var_37);
384 }
385 ,
386 s if s.matches("Location") => {
387 let var_38 =
388 Some(
389 Result::<::std::string::String, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
390 ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
391 .into()
392 )
393 ?
394 )
395 ;
396 builder = builder.set_location(var_38);
397 }
398 ,
399 _ => {}
400 }
401 }
402 Ok(builder)
403}