Skip to main content

aws_sdk_applicationdiscovery/operation/
start_import_task.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `StartImportTask`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct StartImportTask;
6impl StartImportTask {
7    /// Creates a new `StartImportTask`
8    pub fn new() -> Self {
9        Self
10    }
11    pub(crate) async fn orchestrate(
12        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
13        input: crate::operation::start_import_task::StartImportTaskInput,
14    ) -> ::std::result::Result<
15        crate::operation::start_import_task::StartImportTaskOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::start_import_task::StartImportTaskError,
18            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
19        >,
20    > {
21        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
22            ::aws_smithy_runtime_api::client::interceptors::context::Error,
23            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
24        >| {
25            err.map_service_error(|err| {
26                err.downcast::<crate::operation::start_import_task::StartImportTaskError>()
27                    .expect("correct error type")
28            })
29        };
30        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
31            .await
32            .map_err(map_err)?;
33        let output = context.finalize().map_err(map_err)?;
34        ::std::result::Result::Ok(
35            output
36                .downcast::<crate::operation::start_import_task::StartImportTaskOutput>()
37                .expect("correct output type"),
38        )
39    }
40
41    pub(crate) async fn orchestrate_with_stop_point(
42        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
43        input: crate::operation::start_import_task::StartImportTaskInput,
44        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
45    ) -> ::std::result::Result<
46        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
47        ::aws_smithy_runtime_api::client::result::SdkError<
48            ::aws_smithy_runtime_api::client::interceptors::context::Error,
49            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
50        >,
51    > {
52        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
53        use ::tracing::Instrument;
54        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point(
55            "Application Discovery Service",
56            "StartImportTask",
57            input,
58            runtime_plugins,
59            stop_point,
60        )
61        // Create a parent span for the entire operation. Includes a random, internal-only,
62        // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
63        .instrument(::tracing::debug_span!(
64            "Application Discovery Service.StartImportTask",
65            "rpc.service" = "Application Discovery Service",
66            "rpc.method" = "StartImportTask",
67            "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
68            "rpc.system" = "aws-api",
69        ))
70        .await
71    }
72
73    pub(crate) fn operation_runtime_plugins(
74        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
75        client_config: &crate::config::Config,
76        config_override: ::std::option::Option<crate::config::Builder>,
77    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
78        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
79        runtime_plugins = runtime_plugins.with_operation_plugin(crate::client_idempotency_token::IdempotencyTokenRuntimePlugin::new(
80            |token_provider, input| {
81                let input: &mut crate::operation::start_import_task::StartImportTaskInput = input.downcast_mut().expect("correct type");
82                if input.client_request_token.is_none() {
83                    input.client_request_token = ::std::option::Option::Some(token_provider.make_idempotency_token());
84                }
85            },
86        ));
87        if let ::std::option::Option::Some(config_override) = config_override {
88            for plugin in config_override.runtime_plugins.iter().cloned() {
89                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
90            }
91            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
92                config_override,
93                client_config.config.clone(),
94                &client_config.runtime_components,
95            ));
96        }
97        runtime_plugins
98    }
99}
100impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for StartImportTask {
101    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
102        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("StartImportTask");
103
104        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
105            StartImportTaskRequestSerializer,
106        ));
107        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
108            StartImportTaskResponseDeserializer,
109        ));
110
111        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
112            crate::config::auth::Params::builder()
113                .operation_name("StartImportTask")
114                .build()
115                .expect("required fields set"),
116        ));
117
118        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
119            "StartImportTask",
120            "Application Discovery Service",
121        ));
122        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
123        signing_options.double_uri_encode = true;
124        signing_options.content_sha256_header = false;
125        signing_options.normalize_uri_path = true;
126        signing_options.payload_override = None;
127
128        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
129            signing_options,
130            ..::std::default::Default::default()
131        });
132
133        ::std::option::Option::Some(cfg.freeze())
134    }
135
136    fn runtime_components(
137        &self,
138        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
139    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
140        #[allow(unused_mut)]
141        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("StartImportTask")
142            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
143                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
144            ))
145            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
146                StartImportTaskEndpointParamsInterceptor,
147            ))
148            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
149                crate::operation::start_import_task::StartImportTaskError,
150            >::new())
151            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
152                crate::operation::start_import_task::StartImportTaskError,
153            >::new())
154            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
155                crate::operation::start_import_task::StartImportTaskError,
156            >::new());
157
158        ::std::borrow::Cow::Owned(rcb)
159    }
160}
161
162#[derive(Debug)]
163struct StartImportTaskResponseDeserializer;
164impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StartImportTaskResponseDeserializer {
165    fn deserialize_nonstreaming_with_config(
166        &self,
167        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
168        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
169    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
170        let (success, status) = (response.status().is_success(), response.status().as_u16());
171        let headers = response.headers();
172        let body = response.body().bytes().expect("body loaded");
173        #[allow(unused_mut)]
174        let mut force_error = false;
175        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
176        let parse_result = if !success && status != 200 || force_error {
177            crate::protocol_serde::shape_start_import_task::de_start_import_task_http_error(status, headers, body)
178        } else {
179            crate::protocol_serde::shape_start_import_task::de_start_import_task_http_response(status, headers, body)
180        };
181        crate::protocol_serde::type_erase_result(parse_result)
182    }
183}
184#[derive(Debug)]
185struct StartImportTaskRequestSerializer;
186impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StartImportTaskRequestSerializer {
187    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
188    fn serialize_input(
189        &self,
190        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
191        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
192    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
193        let input = input
194            .downcast::<crate::operation::start_import_task::StartImportTaskInput>()
195            .expect("correct type");
196        let _header_serialization_settings = _cfg
197            .load::<crate::serialization_settings::HeaderSerializationSettings>()
198            .cloned()
199            .unwrap_or_default();
200        let mut request_builder = {
201            #[allow(clippy::uninlined_format_args)]
202            fn uri_base(
203                _input: &crate::operation::start_import_task::StartImportTaskInput,
204                output: &mut ::std::string::String,
205            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
206                use ::std::fmt::Write as _;
207                ::std::write!(output, "/").expect("formatting should succeed");
208                ::std::result::Result::Ok(())
209            }
210            #[allow(clippy::unnecessary_wraps)]
211            fn update_http_builder(
212                input: &crate::operation::start_import_task::StartImportTaskInput,
213                builder: ::http_1x::request::Builder,
214            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
215                let mut uri = ::std::string::String::new();
216                uri_base(input, &mut uri)?;
217                ::std::result::Result::Ok(builder.method("POST").uri(uri))
218            }
219            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
220            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
221            builder = _header_serialization_settings.set_default_header(
222                builder,
223                ::http_1x::header::HeaderName::from_static("x-amz-target"),
224                "AWSPoseidonService_V2015_11_01.StartImportTask",
225            );
226            builder
227        };
228        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_start_import_task::ser_start_import_task_input(&input)?);
229        if let Some(content_length) = body.content_length() {
230            let content_length = content_length.to_string();
231            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
232        }
233        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
234    }
235}
236#[derive(Debug)]
237struct StartImportTaskEndpointParamsInterceptor;
238
239#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
240impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartImportTaskEndpointParamsInterceptor {
241    fn name(&self) -> &'static str {
242        "StartImportTaskEndpointParamsInterceptor"
243    }
244
245    fn read_before_execution(
246        &self,
247        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
248            '_,
249            ::aws_smithy_runtime_api::client::interceptors::context::Input,
250            ::aws_smithy_runtime_api::client::interceptors::context::Output,
251            ::aws_smithy_runtime_api::client::interceptors::context::Error,
252        >,
253        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
254    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
255        let _input = context
256            .input()
257            .downcast_ref::<StartImportTaskInput>()
258            .ok_or("failed to downcast to StartImportTaskInput")?;
259
260        let params = crate::config::endpoint::Params::builder()
261            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
262            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
263            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
264            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
265            .build()
266            .map_err(|err| {
267                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
268            })?;
269        cfg.interceptor_state()
270            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
271        ::std::result::Result::Ok(())
272    }
273}
274
275// The get_* functions below are generated from JMESPath expressions in the
276// operationContextParams trait. They target the operation's input shape.
277
278/// Error type for the `StartImportTaskError` operation.
279#[non_exhaustive]
280#[derive(::std::fmt::Debug)]
281pub enum StartImportTaskError {
282    /// <p>The user does not have permission to perform the action. Check the IAM policy associated with this user.</p>
283    AuthorizationErrorException(crate::types::error::AuthorizationErrorException),
284    /// <p>The home Region is not set. Set the home Region to continue.</p>
285    HomeRegionNotSetException(crate::types::error::HomeRegionNotSetException),
286    /// <p>One or more parameters are not valid. Verify the parameters and try again.</p>
287    InvalidParameterException(crate::types::error::InvalidParameterException),
288    /// <p>The value of one or more parameters are either invalid or out of range. Verify the parameter values and try again.</p>
289    InvalidParameterValueException(crate::types::error::InvalidParameterValueException),
290    /// <p>This issue occurs when the same <code>clientRequestToken</code> is used with the <code>StartImportTask</code> action, but with different parameters. For example, you use the same request token but have two different import URLs, you can encounter this issue. If the import tasks are meant to be different, use a different <code>clientRequestToken</code>, and try again.</p>
291    ResourceInUseException(crate::types::error::ResourceInUseException),
292    /// <p>The server experienced an internal error. Try again.</p>
293    ServerInternalErrorException(crate::types::error::ServerInternalErrorException),
294    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
295    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
296    variable wildcard pattern and check `.code()`:
297     \
298    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
299     \
300    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-StartImportTaskError) for what information is available for the error.")]
301    Unhandled(crate::error::sealed_unhandled::Unhandled),
302}
303impl StartImportTaskError {
304    /// Creates the `StartImportTaskError::Unhandled` variant from any error type.
305    pub fn unhandled(
306        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
307    ) -> Self {
308        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
309            source: err.into(),
310            meta: ::std::default::Default::default(),
311        })
312    }
313
314    /// Creates the `StartImportTaskError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
315    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
316        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
317            source: err.clone().into(),
318            meta: err,
319        })
320    }
321    ///
322    /// Returns error metadata, which includes the error code, message,
323    /// request ID, and potentially additional information.
324    ///
325    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
326        match self {
327            Self::AuthorizationErrorException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
328            Self::HomeRegionNotSetException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
329            Self::InvalidParameterException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
330            Self::InvalidParameterValueException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
331            Self::ResourceInUseException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
332            Self::ServerInternalErrorException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
333            Self::Unhandled(e) => &e.meta,
334        }
335    }
336    /// Returns `true` if the error kind is `StartImportTaskError::AuthorizationErrorException`.
337    pub fn is_authorization_error_exception(&self) -> bool {
338        matches!(self, Self::AuthorizationErrorException(_))
339    }
340    /// Returns `true` if the error kind is `StartImportTaskError::HomeRegionNotSetException`.
341    pub fn is_home_region_not_set_exception(&self) -> bool {
342        matches!(self, Self::HomeRegionNotSetException(_))
343    }
344    /// Returns `true` if the error kind is `StartImportTaskError::InvalidParameterException`.
345    pub fn is_invalid_parameter_exception(&self) -> bool {
346        matches!(self, Self::InvalidParameterException(_))
347    }
348    /// Returns `true` if the error kind is `StartImportTaskError::InvalidParameterValueException`.
349    pub fn is_invalid_parameter_value_exception(&self) -> bool {
350        matches!(self, Self::InvalidParameterValueException(_))
351    }
352    /// Returns `true` if the error kind is `StartImportTaskError::ResourceInUseException`.
353    pub fn is_resource_in_use_exception(&self) -> bool {
354        matches!(self, Self::ResourceInUseException(_))
355    }
356    /// Returns `true` if the error kind is `StartImportTaskError::ServerInternalErrorException`.
357    pub fn is_server_internal_error_exception(&self) -> bool {
358        matches!(self, Self::ServerInternalErrorException(_))
359    }
360}
361impl ::std::error::Error for StartImportTaskError {
362    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
363        match self {
364            Self::AuthorizationErrorException(_inner) => ::std::option::Option::Some(_inner),
365            Self::HomeRegionNotSetException(_inner) => ::std::option::Option::Some(_inner),
366            Self::InvalidParameterException(_inner) => ::std::option::Option::Some(_inner),
367            Self::InvalidParameterValueException(_inner) => ::std::option::Option::Some(_inner),
368            Self::ResourceInUseException(_inner) => ::std::option::Option::Some(_inner),
369            Self::ServerInternalErrorException(_inner) => ::std::option::Option::Some(_inner),
370            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
371        }
372    }
373}
374impl ::std::fmt::Display for StartImportTaskError {
375    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
376        match self {
377            Self::AuthorizationErrorException(_inner) => _inner.fmt(f),
378            Self::HomeRegionNotSetException(_inner) => _inner.fmt(f),
379            Self::InvalidParameterException(_inner) => _inner.fmt(f),
380            Self::InvalidParameterValueException(_inner) => _inner.fmt(f),
381            Self::ResourceInUseException(_inner) => _inner.fmt(f),
382            Self::ServerInternalErrorException(_inner) => _inner.fmt(f),
383            Self::Unhandled(_inner) => {
384                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
385                    write!(f, "unhandled error ({code})")
386                } else {
387                    f.write_str("unhandled error")
388                }
389            }
390        }
391    }
392}
393impl ::aws_smithy_types::retry::ProvideErrorKind for StartImportTaskError {
394    fn code(&self) -> ::std::option::Option<&str> {
395        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
396    }
397    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
398        ::std::option::Option::None
399    }
400}
401impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for StartImportTaskError {
402    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
403        match self {
404            Self::AuthorizationErrorException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
405            Self::HomeRegionNotSetException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
406            Self::InvalidParameterException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
407            Self::InvalidParameterValueException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
408            Self::ResourceInUseException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
409            Self::ServerInternalErrorException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
410            Self::Unhandled(_inner) => &_inner.meta,
411        }
412    }
413}
414impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for StartImportTaskError {
415    fn create_unhandled_error(
416        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
417        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
418    ) -> Self {
419        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
420            source,
421            meta: meta.unwrap_or_default(),
422        })
423    }
424}
425impl ::aws_types::request_id::RequestId for crate::operation::start_import_task::StartImportTaskError {
426    fn request_id(&self) -> Option<&str> {
427        self.meta().request_id()
428    }
429}
430
431pub use crate::operation::start_import_task::_start_import_task_input::StartImportTaskInput;
432
433pub use crate::operation::start_import_task::_start_import_task_output::StartImportTaskOutput;
434
435mod _start_import_task_input;
436
437mod _start_import_task_output;
438
439/// Builders
440pub mod builders;