135 139 | crate::operation::verify_mac::VerifyMacError,
|
136 140 | >::new());
|
137 141 |
|
138 142 | ::std::borrow::Cow::Owned(rcb)
|
139 143 | }
|
140 144 | }
|
141 145 |
|
142 146 | #[derive(Debug)]
|
143 147 | struct VerifyMacResponseDeserializer;
|
144 148 | impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for VerifyMacResponseDeserializer {
|
145 - | fn deserialize_nonstreaming(
|
149 + | fn deserialize_nonstreaming_with_config(
|
146 150 | &self,
|
147 151 | response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
|
152 + | _cfg: &::aws_smithy_types::config_bag::ConfigBag,
|
148 153 | ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
|
149 154 | let (success, status) = (response.status().is_success(), response.status().as_u16());
|
150 - | let headers = response.headers();
|
151 - | let body = response.body().bytes().expect("body loaded");
|
152 155 | #[allow(unused_mut)]
|
153 156 | let mut force_error = false;
|
154 157 | ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
|
155 - | let parse_result = if !success && status != 200 || force_error {
|
156 - | crate::protocol_serde::shape_verify_mac::de_verify_mac_http_error(status, headers, body)
|
157 - | } else {
|
158 - | crate::protocol_serde::shape_verify_mac::de_verify_mac_http_response(status, headers, body)
|
158 + | if !success && status != 200 || force_error {
|
159 + | let headers = response.headers();
|
160 + | let body = response.body().bytes().expect("body loaded");
|
161 + | #[allow(unused_mut)]
|
162 + | let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
|
163 + | ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
|
164 + | })?;
|
165 + | generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
|
166 + | let generic = generic_builder.build();
|
167 + | let error_code = match generic.code() {
|
168 + | ::std::option::Option::Some(code) => code,
|
169 + | ::std::option::Option::None => {
|
170 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
171 + | ::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::verify_mac::VerifyMacError::unhandled(generic)),
|
172 + | ))
|
173 + | }
|
174 + | };
|
175 + | let _error_message = generic.message().map(|msg| msg.to_owned());
|
176 + | let protocol = _cfg
|
177 + | .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
|
178 + | .expect("a SharedClientProtocol is required");
|
179 + | let err = match error_code {
|
180 + | "DisabledException" => crate::operation::verify_mac::VerifyMacError::DisabledException({
|
181 + | let mut tmp = match protocol
|
182 + | .deserialize_response(response, crate::types::error::DisabledException::SCHEMA, _cfg)
|
183 + | .and_then(|mut deser| {
|
184 + | crate::types::error::DisabledException::deserialize_with_response(
|
185 + | &mut *deser,
|
186 + | response.headers(),
|
187 + | response.status().into(),
|
188 + | body,
|
189 + | )
|
190 + | }) {
|
191 + | ::std::result::Result::Ok(val) => val,
|
192 + | ::std::result::Result::Err(e) => {
|
193 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
194 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
195 + | ))
|
196 + | }
|
197 + | };
|
198 + | tmp.meta = generic;
|
199 + | if tmp.message.is_none() {
|
200 + | tmp.message = _error_message;
|
201 + | }
|
202 + | tmp
|
203 + | }),
|
204 + | "DryRunOperationException" => crate::operation::verify_mac::VerifyMacError::DryRunOperationException({
|
205 + | let mut tmp = match protocol
|
206 + | .deserialize_response(response, crate::types::error::DryRunOperationException::SCHEMA, _cfg)
|
207 + | .and_then(|mut deser| {
|
208 + | crate::types::error::DryRunOperationException::deserialize_with_response(
|
209 + | &mut *deser,
|
210 + | response.headers(),
|
211 + | response.status().into(),
|
212 + | body,
|
213 + | )
|
214 + | }) {
|
215 + | ::std::result::Result::Ok(val) => val,
|
216 + | ::std::result::Result::Err(e) => {
|
217 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
218 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
219 + | ))
|
220 + | }
|
221 + | };
|
222 + | tmp.meta = generic;
|
223 + | if tmp.message.is_none() {
|
224 + | tmp.message = _error_message;
|
225 + | }
|
226 + | tmp
|
227 + | }),
|
228 + | "InvalidGrantTokenException" => crate::operation::verify_mac::VerifyMacError::InvalidGrantTokenException({
|
229 + | let mut tmp = match protocol
|
230 + | .deserialize_response(response, crate::types::error::InvalidGrantTokenException::SCHEMA, _cfg)
|
231 + | .and_then(|mut deser| {
|
232 + | crate::types::error::InvalidGrantTokenException::deserialize_with_response(
|
233 + | &mut *deser,
|
234 + | response.headers(),
|
235 + | response.status().into(),
|
236 + | body,
|
237 + | )
|
238 + | }) {
|
239 + | ::std::result::Result::Ok(val) => val,
|
240 + | ::std::result::Result::Err(e) => {
|
241 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
242 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
243 + | ))
|
244 + | }
|
159 245 | };
|
160 - | crate::protocol_serde::type_erase_result(parse_result)
|
246 + | tmp.meta = generic;
|
247 + | if tmp.message.is_none() {
|
248 + | tmp.message = _error_message;
|
249 + | }
|
250 + | tmp
|
251 + | }),
|
252 + | "InvalidKeyUsageException" => crate::operation::verify_mac::VerifyMacError::InvalidKeyUsageException({
|
253 + | let mut tmp = match protocol
|
254 + | .deserialize_response(response, crate::types::error::InvalidKeyUsageException::SCHEMA, _cfg)
|
255 + | .and_then(|mut deser| {
|
256 + | crate::types::error::InvalidKeyUsageException::deserialize_with_response(
|
257 + | &mut *deser,
|
258 + | response.headers(),
|
259 + | response.status().into(),
|
260 + | body,
|
261 + | )
|
262 + | }) {
|
263 + | ::std::result::Result::Ok(val) => val,
|
264 + | ::std::result::Result::Err(e) => {
|
265 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
266 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
267 + | ))
|
268 + | }
|
269 + | };
|
270 + | tmp.meta = generic;
|
271 + | if tmp.message.is_none() {
|
272 + | tmp.message = _error_message;
|
273 + | }
|
274 + | tmp
|
275 + | }),
|
276 + | "KeyUnavailableException" => crate::operation::verify_mac::VerifyMacError::KeyUnavailableException({
|
277 + | let mut tmp = match protocol
|
278 + | .deserialize_response(response, crate::types::error::KeyUnavailableException::SCHEMA, _cfg)
|
279 + | .and_then(|mut deser| {
|
280 + | crate::types::error::KeyUnavailableException::deserialize_with_response(
|
281 + | &mut *deser,
|
282 + | response.headers(),
|
283 + | response.status().into(),
|
284 + | body,
|
285 + | )
|
286 + | }) {
|
287 + | ::std::result::Result::Ok(val) => val,
|
288 + | ::std::result::Result::Err(e) => {
|
289 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
290 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
291 + | ))
|
292 + | }
|
293 + | };
|
294 + | tmp.meta = generic;
|
295 + | if tmp.message.is_none() {
|
296 + | tmp.message = _error_message;
|
297 + | }
|
298 + | tmp
|
299 + | }),
|
300 + | "KMSInternalException" => crate::operation::verify_mac::VerifyMacError::KmsInternalException({
|
301 + | let mut tmp = match protocol
|
302 + | .deserialize_response(response, crate::types::error::KmsInternalException::SCHEMA, _cfg)
|
303 + | .and_then(|mut deser| {
|
304 + | crate::types::error::KmsInternalException::deserialize_with_response(
|
305 + | &mut *deser,
|
306 + | response.headers(),
|
307 + | response.status().into(),
|
308 + | body,
|
309 + | )
|
310 + | }) {
|
311 + | ::std::result::Result::Ok(val) => val,
|
312 + | ::std::result::Result::Err(e) => {
|
313 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
314 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
315 + | ))
|
316 + | }
|
317 + | };
|
318 + | tmp.meta = generic;
|
319 + | if tmp.message.is_none() {
|
320 + | tmp.message = _error_message;
|
321 + | }
|
322 + | tmp
|
323 + | }),
|
324 + | "KMSInvalidMacException" => crate::operation::verify_mac::VerifyMacError::KmsInvalidMacException({
|
325 + | let mut tmp = match protocol
|
326 + | .deserialize_response(response, crate::types::error::KmsInvalidMacException::SCHEMA, _cfg)
|
327 + | .and_then(|mut deser| {
|
328 + | crate::types::error::KmsInvalidMacException::deserialize_with_response(
|
329 + | &mut *deser,
|
330 + | response.headers(),
|
331 + | response.status().into(),
|
332 + | body,
|
333 + | )
|
334 + | }) {
|
335 + | ::std::result::Result::Ok(val) => val,
|
336 + | ::std::result::Result::Err(e) => {
|
337 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
338 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
339 + | ))
|
340 + | }
|
341 + | };
|
342 + | tmp.meta = generic;
|
343 + | if tmp.message.is_none() {
|
344 + | tmp.message = _error_message;
|
345 + | }
|
346 + | tmp
|
347 + | }),
|
348 + | "KMSInvalidStateException" => crate::operation::verify_mac::VerifyMacError::KmsInvalidStateException({
|
349 + | let mut tmp = match protocol
|
350 + | .deserialize_response(response, crate::types::error::KmsInvalidStateException::SCHEMA, _cfg)
|
351 + | .and_then(|mut deser| {
|
352 + | crate::types::error::KmsInvalidStateException::deserialize_with_response(
|
353 + | &mut *deser,
|
354 + | response.headers(),
|
355 + | response.status().into(),
|
356 + | body,
|
357 + | )
|
358 + | }) {
|
359 + | ::std::result::Result::Ok(val) => val,
|
360 + | ::std::result::Result::Err(e) => {
|
361 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
362 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
363 + | ))
|
364 + | }
|
365 + | };
|
366 + | tmp.meta = generic;
|
367 + | if tmp.message.is_none() {
|
368 + | tmp.message = _error_message;
|
369 + | }
|
370 + | tmp
|
371 + | }),
|
372 + | "NotFoundException" => crate::operation::verify_mac::VerifyMacError::NotFoundException({
|
373 + | let mut tmp = match protocol
|
374 + | .deserialize_response(response, crate::types::error::NotFoundException::SCHEMA, _cfg)
|
375 + | .and_then(|mut deser| {
|
376 + | crate::types::error::NotFoundException::deserialize_with_response(
|
377 + | &mut *deser,
|
378 + | response.headers(),
|
379 + | response.status().into(),
|
380 + | body,
|
381 + | )
|
382 + | }) {
|
383 + | ::std::result::Result::Ok(val) => val,
|
384 + | ::std::result::Result::Err(e) => {
|
385 + | return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
|
386 + | ::aws_smithy_runtime_api::box_error::BoxError::from(e),
|
387 + | ))
|
388 + | }
|
389 + | };
|
390 + | tmp.meta = generic;
|
391 + | if tmp.message.is_none() {
|
392 + | tmp.message = _error_message;
|
393 + | }
|
394 + | tmp
|
395 + | }),
|
396 + | _ => crate::operation::verify_mac::VerifyMacError::generic(generic),
|
397 + | };
|
398 + | ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
|
399 + | ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
|
400 + | ))
|
401 + | } else {
|
402 + | let protocol = _cfg
|
403 + | .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
|
404 + | .expect("a SharedClientProtocol is required");
|
405 + | let mut deser = protocol.deserialize_response(response, VerifyMac::OUTPUT_SCHEMA, _cfg).map_err(|e| {
|
406 + | ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
|
407 + | })?;
|
408 + | let body = response.body().bytes().expect("body loaded");
|
409 + | let output = crate::operation::verify_mac::VerifyMacOutput::deserialize_with_response(
|
410 + | &mut *deser,
|
411 + | response.headers(),
|
412 + | response.status().into(),
|
413 + | body,
|
414 + | )
|
415 + | .map_err(|e| {
|
416 + | ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
|
417 + | })?;
|
418 + | ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
|
419 + | }
|
161 420 | }
|
162 421 | }
|
163 422 | #[derive(Debug)]
|
164 423 | struct VerifyMacRequestSerializer;
|
165 424 | impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for VerifyMacRequestSerializer {
|
166 425 | #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
|
167 426 | fn serialize_input(
|
168 427 | &self,
|
169 428 | input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
|
170 429 | _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
|
171 430 | ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
|
172 431 | let input = input.downcast::<crate::operation::verify_mac::VerifyMacInput>().expect("correct type");
|
173 - | let _header_serialization_settings = _cfg
|
174 - | .load::<crate::serialization_settings::HeaderSerializationSettings>()
|
175 - | .cloned()
|
176 - | .unwrap_or_default();
|
177 - | let mut request_builder = {
|
178 - | #[allow(clippy::uninlined_format_args)]
|
179 - | fn uri_base(
|
180 - | _input: &crate::operation::verify_mac::VerifyMacInput,
|
181 - | output: &mut ::std::string::String,
|
182 - | ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
|
183 - | use ::std::fmt::Write as _;
|
184 - | ::std::write!(output, "/").expect("formatting should succeed");
|
185 - | ::std::result::Result::Ok(())
|
186 - | }
|
187 - | #[allow(clippy::unnecessary_wraps)]
|
188 - | fn update_http_builder(
|
189 - | input: &crate::operation::verify_mac::VerifyMacInput,
|
190 - | builder: ::http_1x::request::Builder,
|
191 - | ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
|
192 - | let mut uri = ::std::string::String::new();
|
193 - | uri_base(input, &mut uri)?;
|
194 - | ::std::result::Result::Ok(builder.method("POST").uri(uri))
|
195 - | }
|
196 - | let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
|
197 - | builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
|
198 - | builder = _header_serialization_settings.set_default_header(
|
199 - | builder,
|
200 - | ::http_1x::header::HeaderName::from_static("x-amz-target"),
|
201 - | "TrentService.VerifyMac",
|
202 - | );
|
203 - | builder
|
204 - | };
|
205 - | let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_verify_mac::ser_verify_mac_input(&input)?);
|
206 - | if let Some(content_length) = body.content_length() {
|
207 - | let content_length = content_length.to_string();
|
208 - | request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
|
209 - | }
|
210 - | ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
|
432 + | let protocol = _cfg
|
433 + | .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
|
434 + | .expect("a SharedClientProtocol is required");
|
435 + | let mut request = protocol
|
436 + | .serialize_request(&input, VerifyMac::INPUT_SCHEMA, "", _cfg)
|
437 + | .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
|
438 + |
|
439 + | return ::std::result::Result::Ok(request);
|
211 440 | }
|
212 441 | }
|
213 442 | #[derive(Debug)]
|
214 443 | struct VerifyMacEndpointParamsInterceptor;
|
215 444 |
|
216 445 | impl ::aws_smithy_runtime_api::client::interceptors::Intercept for VerifyMacEndpointParamsInterceptor {
|
217 446 | fn name(&self) -> &'static str {
|
218 447 | "VerifyMacEndpointParamsInterceptor"
|
219 448 | }
|
220 449 |
|