aws_sdk_redshift/protocol_serde/
shape_modify_cluster.rs1#[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") => {
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}