aws_sdk_redshift/protocol_serde/
shape_modify_cluster.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2#[allow(clippy::unnecessary_wraps)]
3pub fn de_modify_cluster_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::modify_cluster::ModifyClusterOutput, crate::operation::modify_cluster::ModifyClusterError> {
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::modify_cluster::ModifyClusterError::unhandled)?;
11    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
12    let generic = generic_builder.build();
13    let error_code = match generic.code() {
14        Some(code) => code,
15        None => return Err(crate::operation::modify_cluster::ModifyClusterError::unhandled(generic)),
16    };
17
18    let _error_message = generic.message().map(|msg| msg.to_owned());
19    Err(match error_code {
20        "ClusterAlreadyExists" => crate::operation::modify_cluster::ModifyClusterError::ClusterAlreadyExistsFault({
21            #[allow(unused_mut)]
22            let mut tmp = {
23                #[allow(unused_mut)]
24                let mut output = crate::types::error::builders::ClusterAlreadyExistsFaultBuilder::default();
25                output = crate::protocol_serde::shape_cluster_already_exists_fault::de_cluster_already_exists_fault_xml_err(_response_body, output)
26                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
27                let output = output.meta(generic);
28                output.build()
29            };
30            if tmp.message.is_none() {
31                tmp.message = _error_message;
32            }
33            tmp
34        }),
35        "ClusterNotFound" => crate::operation::modify_cluster::ModifyClusterError::ClusterNotFoundFault({
36            #[allow(unused_mut)]
37            let mut tmp = {
38                #[allow(unused_mut)]
39                let mut output = crate::types::error::builders::ClusterNotFoundFaultBuilder::default();
40                output = crate::protocol_serde::shape_cluster_not_found_fault::de_cluster_not_found_fault_xml_err(_response_body, output)
41                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
42                let output = output.meta(generic);
43                output.build()
44            };
45            if tmp.message.is_none() {
46                tmp.message = _error_message;
47            }
48            tmp
49        }),
50        "ClusterParameterGroupNotFound" => crate::operation::modify_cluster::ModifyClusterError::ClusterParameterGroupNotFoundFault({
51            #[allow(unused_mut)]
52            let mut tmp = {
53                #[allow(unused_mut)]
54                let mut output = crate::types::error::builders::ClusterParameterGroupNotFoundFaultBuilder::default();
55                output = crate::protocol_serde::shape_cluster_parameter_group_not_found_fault::de_cluster_parameter_group_not_found_fault_xml_err(
56                    _response_body,
57                    output,
58                )
59                .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
60                let output = output.meta(generic);
61                output.build()
62            };
63            if tmp.message.is_none() {
64                tmp.message = _error_message;
65            }
66            tmp
67        }),
68        "ClusterSecurityGroupNotFound" => crate::operation::modify_cluster::ModifyClusterError::ClusterSecurityGroupNotFoundFault({
69            #[allow(unused_mut)]
70            let mut tmp = {
71                #[allow(unused_mut)]
72                let mut output = crate::types::error::builders::ClusterSecurityGroupNotFoundFaultBuilder::default();
73                output = crate::protocol_serde::shape_cluster_security_group_not_found_fault::de_cluster_security_group_not_found_fault_xml_err(
74                    _response_body,
75                    output,
76                )
77                .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
78                let output = output.meta(generic);
79                output.build()
80            };
81            if tmp.message.is_none() {
82                tmp.message = _error_message;
83            }
84            tmp
85        }),
86        "CustomCnameAssociationFault" => crate::operation::modify_cluster::ModifyClusterError::CustomCnameAssociationFault({
87            #[allow(unused_mut)]
88            let mut tmp = {
89                #[allow(unused_mut)]
90                let mut output = crate::types::error::builders::CustomCnameAssociationFaultBuilder::default();
91                output =
92                    crate::protocol_serde::shape_custom_cname_association_fault::de_custom_cname_association_fault_xml_err(_response_body, output)
93                        .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
94                let output = output.meta(generic);
95                output.build()
96            };
97            if tmp.message.is_none() {
98                tmp.message = _error_message;
99            }
100            tmp
101        }),
102        "DependentServiceRequestThrottlingFault" => {
103            crate::operation::modify_cluster::ModifyClusterError::DependentServiceRequestThrottlingFault({
104                #[allow(unused_mut)]
105                let mut tmp = {
106                    #[allow(unused_mut)]
107                    let mut output = crate::types::error::builders::DependentServiceRequestThrottlingFaultBuilder::default();
108                    output = crate::protocol_serde::shape_dependent_service_request_throttling_fault::de_dependent_service_request_throttling_fault_xml_err(_response_body, output).map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
109                    let output = output.meta(generic);
110                    output.build()
111                };
112                if tmp.message.is_none() {
113                    tmp.message = _error_message;
114                }
115                tmp
116            })
117        }
118        "HsmClientCertificateNotFoundFault" => crate::operation::modify_cluster::ModifyClusterError::HsmClientCertificateNotFoundFault({
119            #[allow(unused_mut)]
120            let mut tmp = {
121                #[allow(unused_mut)]
122                let mut output = crate::types::error::builders::HsmClientCertificateNotFoundFaultBuilder::default();
123                output = crate::protocol_serde::shape_hsm_client_certificate_not_found_fault::de_hsm_client_certificate_not_found_fault_xml_err(
124                    _response_body,
125                    output,
126                )
127                .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
128                let output = output.meta(generic);
129                output.build()
130            };
131            if tmp.message.is_none() {
132                tmp.message = _error_message;
133            }
134            tmp
135        }),
136        "HsmConfigurationNotFoundFault" => crate::operation::modify_cluster::ModifyClusterError::HsmConfigurationNotFoundFault({
137            #[allow(unused_mut)]
138            let mut tmp = {
139                #[allow(unused_mut)]
140                let mut output = crate::types::error::builders::HsmConfigurationNotFoundFaultBuilder::default();
141                output = crate::protocol_serde::shape_hsm_configuration_not_found_fault::de_hsm_configuration_not_found_fault_xml_err(
142                    _response_body,
143                    output,
144                )
145                .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
146                let output = output.meta(generic);
147                output.build()
148            };
149            if tmp.message.is_none() {
150                tmp.message = _error_message;
151            }
152            tmp
153        }),
154        "InsufficientClusterCapacity" => crate::operation::modify_cluster::ModifyClusterError::InsufficientClusterCapacityFault({
155            #[allow(unused_mut)]
156            let mut tmp = {
157                #[allow(unused_mut)]
158                let mut output = crate::types::error::builders::InsufficientClusterCapacityFaultBuilder::default();
159                output = crate::protocol_serde::shape_insufficient_cluster_capacity_fault::de_insufficient_cluster_capacity_fault_xml_err(
160                    _response_body,
161                    output,
162                )
163                .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
164                let output = output.meta(generic);
165                output.build()
166            };
167            if tmp.message.is_none() {
168                tmp.message = _error_message;
169            }
170            tmp
171        }),
172        "InvalidClusterSecurityGroupState" => {
173            crate::operation::modify_cluster::ModifyClusterError::InvalidClusterSecurityGroupStateFault({
174                #[allow(unused_mut)]
175                let mut tmp = {
176                    #[allow(unused_mut)]
177                    let mut output = crate::types::error::builders::InvalidClusterSecurityGroupStateFaultBuilder::default();
178                    output = crate::protocol_serde::shape_invalid_cluster_security_group_state_fault::de_invalid_cluster_security_group_state_fault_xml_err(_response_body, output).map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
179                    let output = output.meta(generic);
180                    output.build()
181                };
182                if tmp.message.is_none() {
183                    tmp.message = _error_message;
184                }
185                tmp
186            })
187        }
188        "InvalidClusterState" => crate::operation::modify_cluster::ModifyClusterError::InvalidClusterStateFault({
189            #[allow(unused_mut)]
190            let mut tmp = {
191                #[allow(unused_mut)]
192                let mut output = crate::types::error::builders::InvalidClusterStateFaultBuilder::default();
193                output = crate::protocol_serde::shape_invalid_cluster_state_fault::de_invalid_cluster_state_fault_xml_err(_response_body, output)
194                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
195                let output = output.meta(generic);
196                output.build()
197            };
198            if tmp.message.is_none() {
199                tmp.message = _error_message;
200            }
201            tmp
202        }),
203        "InvalidClusterTrack" => crate::operation::modify_cluster::ModifyClusterError::InvalidClusterTrackFault({
204            #[allow(unused_mut)]
205            let mut tmp = {
206                #[allow(unused_mut)]
207                let mut output = crate::types::error::builders::InvalidClusterTrackFaultBuilder::default();
208                output = crate::protocol_serde::shape_invalid_cluster_track_fault::de_invalid_cluster_track_fault_xml_err(_response_body, output)
209                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
210                let output = output.meta(generic);
211                output.build()
212            };
213            if tmp.message.is_none() {
214                tmp.message = _error_message;
215            }
216            tmp
217        }),
218        "InvalidElasticIpFault" => crate::operation::modify_cluster::ModifyClusterError::InvalidElasticIpFault({
219            #[allow(unused_mut)]
220            let mut tmp = {
221                #[allow(unused_mut)]
222                let mut output = crate::types::error::builders::InvalidElasticIpFaultBuilder::default();
223                output = crate::protocol_serde::shape_invalid_elastic_ip_fault::de_invalid_elastic_ip_fault_xml_err(_response_body, output)
224                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
225                let output = output.meta(generic);
226                output.build()
227            };
228            if tmp.message.is_none() {
229                tmp.message = _error_message;
230            }
231            tmp
232        }),
233        "InvalidRetentionPeriodFault" => crate::operation::modify_cluster::ModifyClusterError::InvalidRetentionPeriodFault({
234            #[allow(unused_mut)]
235            let mut tmp = {
236                #[allow(unused_mut)]
237                let mut output = crate::types::error::builders::InvalidRetentionPeriodFaultBuilder::default();
238                output =
239                    crate::protocol_serde::shape_invalid_retention_period_fault::de_invalid_retention_period_fault_xml_err(_response_body, output)
240                        .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
241                let output = output.meta(generic);
242                output.build()
243            };
244            if tmp.message.is_none() {
245                tmp.message = _error_message;
246            }
247            tmp
248        }),
249        "Ipv6CidrBlockNotFoundFault" => crate::operation::modify_cluster::ModifyClusterError::Ipv6CidrBlockNotFoundFault({
250            #[allow(unused_mut)]
251            let mut tmp = {
252                #[allow(unused_mut)]
253                let mut output = crate::types::error::builders::Ipv6CidrBlockNotFoundFaultBuilder::default();
254                output =
255                    crate::protocol_serde::shape_ipv6_cidr_block_not_found_fault::de_ipv6_cidr_block_not_found_fault_xml_err(_response_body, output)
256                        .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
257                let output = output.meta(generic);
258                output.build()
259            };
260            if tmp.message.is_none() {
261                tmp.message = _error_message;
262            }
263            tmp
264        }),
265        "LimitExceededFault" => crate::operation::modify_cluster::ModifyClusterError::LimitExceededFault({
266            #[allow(unused_mut)]
267            let mut tmp = {
268                #[allow(unused_mut)]
269                let mut output = crate::types::error::builders::LimitExceededFaultBuilder::default();
270                output = crate::protocol_serde::shape_limit_exceeded_fault::de_limit_exceeded_fault_xml_err(_response_body, output)
271                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
272                let output = output.meta(generic);
273                output.build()
274            };
275            if tmp.message.is_none() {
276                tmp.message = _error_message;
277            }
278            tmp
279        }),
280        "NumberOfNodesPerClusterLimitExceeded" => crate::operation::modify_cluster::ModifyClusterError::NumberOfNodesPerClusterLimitExceededFault({
281            #[allow(unused_mut)]
282            let mut tmp = {
283                #[allow(unused_mut)]
284                let mut output = crate::types::error::builders::NumberOfNodesPerClusterLimitExceededFaultBuilder::default();
285                output = crate::protocol_serde::shape_number_of_nodes_per_cluster_limit_exceeded_fault::de_number_of_nodes_per_cluster_limit_exceeded_fault_xml_err(_response_body, output).map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
286                let output = output.meta(generic);
287                output.build()
288            };
289            if tmp.message.is_none() {
290                tmp.message = _error_message;
291            }
292            tmp
293        }),
294        "NumberOfNodesQuotaExceeded" => crate::operation::modify_cluster::ModifyClusterError::NumberOfNodesQuotaExceededFault({
295            #[allow(unused_mut)]
296            let mut tmp = {
297                #[allow(unused_mut)]
298                let mut output = crate::types::error::builders::NumberOfNodesQuotaExceededFaultBuilder::default();
299                output = crate::protocol_serde::shape_number_of_nodes_quota_exceeded_fault::de_number_of_nodes_quota_exceeded_fault_xml_err(
300                    _response_body,
301                    output,
302                )
303                .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
304                let output = output.meta(generic);
305                output.build()
306            };
307            if tmp.message.is_none() {
308                tmp.message = _error_message;
309            }
310            tmp
311        }),
312        "TableLimitExceeded" => crate::operation::modify_cluster::ModifyClusterError::TableLimitExceededFault({
313            #[allow(unused_mut)]
314            let mut tmp = {
315                #[allow(unused_mut)]
316                let mut output = crate::types::error::builders::TableLimitExceededFaultBuilder::default();
317                output = crate::protocol_serde::shape_table_limit_exceeded_fault::de_table_limit_exceeded_fault_xml_err(_response_body, output)
318                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
319                let output = output.meta(generic);
320                output.build()
321            };
322            if tmp.message.is_none() {
323                tmp.message = _error_message;
324            }
325            tmp
326        }),
327        "UnauthorizedOperation" => crate::operation::modify_cluster::ModifyClusterError::UnauthorizedOperation({
328            #[allow(unused_mut)]
329            let mut tmp = {
330                #[allow(unused_mut)]
331                let mut output = crate::types::error::builders::UnauthorizedOperationBuilder::default();
332                output = crate::protocol_serde::shape_unauthorized_operation::de_unauthorized_operation_xml_err(_response_body, output)
333                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
334                let output = output.meta(generic);
335                output.build()
336            };
337            if tmp.message.is_none() {
338                tmp.message = _error_message;
339            }
340            tmp
341        }),
342        "UnsupportedOperation" => crate::operation::modify_cluster::ModifyClusterError::UnsupportedOperationFault({
343            #[allow(unused_mut)]
344            let mut tmp = {
345                #[allow(unused_mut)]
346                let mut output = crate::types::error::builders::UnsupportedOperationFaultBuilder::default();
347                output = crate::protocol_serde::shape_unsupported_operation_fault::de_unsupported_operation_fault_xml_err(_response_body, output)
348                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
349                let output = output.meta(generic);
350                output.build()
351            };
352            if tmp.message.is_none() {
353                tmp.message = _error_message;
354            }
355            tmp
356        }),
357        "UnsupportedOptionFault" => crate::operation::modify_cluster::ModifyClusterError::UnsupportedOptionFault({
358            #[allow(unused_mut)]
359            let mut tmp = {
360                #[allow(unused_mut)]
361                let mut output = crate::types::error::builders::UnsupportedOptionFaultBuilder::default();
362                output = crate::protocol_serde::shape_unsupported_option_fault::de_unsupported_option_fault_xml_err(_response_body, output)
363                    .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
364                let output = output.meta(generic);
365                output.build()
366            };
367            if tmp.message.is_none() {
368                tmp.message = _error_message;
369            }
370            tmp
371        }),
372        _ => crate::operation::modify_cluster::ModifyClusterError::generic(generic),
373    })
374}
375
376#[allow(clippy::unnecessary_wraps)]
377pub fn de_modify_cluster_http_response(
378    _response_status: u16,
379    _response_headers: &::aws_smithy_runtime_api::http::Headers,
380    _response_body: &[u8],
381) -> std::result::Result<crate::operation::modify_cluster::ModifyClusterOutput, crate::operation::modify_cluster::ModifyClusterError> {
382    Ok({
383        #[allow(unused_mut)]
384        let mut output = crate::operation::modify_cluster::builders::ModifyClusterOutputBuilder::default();
385        output = crate::protocol_serde::shape_modify_cluster::de_modify_cluster(_response_body, output)
386            .map_err(crate::operation::modify_cluster::ModifyClusterError::unhandled)?;
387        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
388        output.build()
389    })
390}
391
392#[allow(unused_mut)]
393pub fn de_modify_cluster(
394    inp: &[u8],
395    mut builder: crate::operation::modify_cluster::builders::ModifyClusterOutputBuilder,
396) -> std::result::Result<crate::operation::modify_cluster::builders::ModifyClusterOutputBuilder, ::aws_smithy_xml::decode::XmlDecodeError> {
397    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
398
399    #[allow(unused_mut)]
400    let mut decoder = doc.root_element()?;
401    #[allow(unused_variables)]
402    let start_el = decoder.start_el();
403    if !(start_el.matches("ModifyClusterResponse")) {
404        return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
405            "invalid root, expected ModifyClusterResponse got {:?}",
406            start_el
407        )));
408    }
409    if let Some(mut result_tag) = decoder.next_tag() {
410        let start_el = result_tag.start_el();
411        if !(start_el.matches("ModifyClusterResult")) {
412            return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
413                "invalid result, expected ModifyClusterResult got {:?}",
414                start_el
415            )));
416        }
417        while let Some(mut tag) = result_tag.next_tag() {
418            match tag.start_el() {
419            s if s.matches("Cluster") /* Cluster com.amazonaws.redshift.synthetic#ModifyClusterOutput$Cluster */ =>  {
420                let var_1 =
421                    Some(
422                        crate::protocol_serde::shape_cluster::de_cluster(&mut tag)
423                        ?
424                    )
425                ;
426                builder = builder.set_cluster(var_1);
427            }
428            ,
429            _ => {}
430        }
431        }
432    } else {
433        return Err(::aws_smithy_xml::decode::XmlDecodeError::custom("expected ModifyClusterResult tag"));
434    };
435    Ok(builder)
436}