Struct aws_sdk_ec2::input::DescribeLaunchTemplateVersionsInput

#[non_exhaustive]
pub struct DescribeLaunchTemplateVersionsInput { /* private fields */ }

Implementations

impl DescribeLaunchTemplateVersionsInput

pub async fn make_operation(
    &self,
    _config: &Config
) -> Result<Operation<DescribeLaunchTemplateVersions, AwsResponseRetryClassifier>, BuildError>

Consumes the builder and constructs an Operation<DescribeLaunchTemplateVersions>

Examples found in repository

src/client.rs (line 40922)

        pub async fn customize(
            self,
        ) -> std::result::Result<
            crate::operation::customize::CustomizableOperation<
                crate::operation::DescribeLaunchTemplateVersions,
                aws_http::retry::AwsResponseRetryClassifier,
            >,
            aws_smithy_http::result::SdkError<crate::error::DescribeLaunchTemplateVersionsError>,
        > {
            let handle = self.handle.clone();
            let operation = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            Ok(crate::operation::customize::CustomizableOperation { handle, operation })
        }

        /// Sends the request and returns the response.
        ///
        /// If an error occurs, an `SdkError` will be returned with additional details that
        /// can be matched against.
        ///
        /// By default, any retryable failures will be retried twice. Retry behavior
        /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
        /// set when configuring the client.
        pub async fn send(
            self,
        ) -> std::result::Result<
            crate::output::DescribeLaunchTemplateVersionsOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeLaunchTemplateVersionsError>,
        > {
            let op = self
                .inner
                .build()
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?
                .make_operation(&self.handle.conf)
                .await
                .map_err(aws_smithy_http::result::SdkError::construction_failure)?;
            self.handle.client.call(op).await
        }

src/paginator.rs (line 4571)

    pub fn send(
        self,
    ) -> impl tokio_stream::Stream<
        Item = std::result::Result<
            crate::output::DescribeLaunchTemplateVersionsOutput,
            aws_smithy_http::result::SdkError<crate::error::DescribeLaunchTemplateVersionsError>,
        >,
    > + Unpin {
        // Move individual fields out of self for the borrow checker
        let builder = self.builder;
        let handle = self.handle;
        aws_smithy_async::future::fn_stream::FnStream::new(move |tx| {
            Box::pin(async move {
                // Build the input for the first time. If required fields are missing, this is where we'll produce an early error.
                let mut input = match builder
                    .build()
                    .map_err(aws_smithy_http::result::SdkError::construction_failure)
                {
                    Ok(input) => input,
                    Err(e) => {
                        let _ = tx.send(Err(e)).await;
                        return;
                    }
                };
                loop {
                    let op = match input
                        .make_operation(&handle.conf)
                        .await
                        .map_err(aws_smithy_http::result::SdkError::construction_failure)
                    {
                        Ok(op) => op,
                        Err(e) => {
                            let _ = tx.send(Err(e)).await;
                            return;
                        }
                    };
                    let resp = handle.client.call(op).await;
                    // If the input member is None or it was an error
                    let done = match resp {
                        Ok(ref resp) => {
                            let new_token = crate::lens::reflens_structure_crate_output_describe_launch_template_versions_output_next_token(resp);
                            let is_empty = new_token.map(|token| token.is_empty()).unwrap_or(true);
                            if !is_empty
                                && new_token == input.next_token.as_ref()
                                && self.stop_on_duplicate_token
                            {
                                true
                            } else {
                                input.next_token = new_token.cloned();
                                is_empty
                            }
                        }
                        Err(_) => true,
                    };
                    if tx.send(resp).await.is_err() {
                        // receiving end was dropped
                        return;
                    }
                    if done {
                        return;
                    }
                }
            })
        })
    }

pub fn builder() -> Builder

Creates a new builder-style object to manufacture DescribeLaunchTemplateVersionsInput.

impl DescribeLaunchTemplateVersionsInput

pub fn dry_run(&self) -> Option<bool>

Checks whether you have the required permissions for the action, without actually making the request, and provides an error response. If you have the required permissions, the error response is DryRunOperation. Otherwise, it is UnauthorizedOperation.

pub fn launch_template_id(&self) -> Option<&str>

The ID of the launch template.

To describe one or more versions of a specified launch template, you must specify either the LaunchTemplateId or the LaunchTemplateName, but not both.

To describe all the latest or default launch template versions in your account, you must omit this parameter.

pub fn launch_template_name(&self) -> Option<&str>

The name of the launch template.

To describe one or more versions of a specified launch template, you must specify either the LaunchTemplateName or the LaunchTemplateId, but not both.

To describe all the latest or default launch template versions in your account, you must omit this parameter.

pub fn versions(&self) -> Option<&[String]>

One or more versions of the launch template. Valid values depend on whether you are describing a specified launch template (by ID or name) or all launch templates in your account.

To describe one or more versions of a specified launch template, valid values are $Latest, $Default, and numbers.

To describe all launch templates in your account that are defined as the latest version, the valid value is $Latest. To describe all launch templates in your account that are defined as the default version, the valid value is $Default. You can specify $Latest and $Default in the same request. You cannot specify numbers.

pub fn min_version(&self) -> Option<&str>

The version number after which to describe launch template versions.

pub fn max_version(&self) -> Option<&str>

The version number up to which to describe launch template versions.

pub fn next_token(&self) -> Option<&str>

The token to request the next page of results.

pub fn max_results(&self) -> Option<i32>

The maximum number of results to return in a single call. To retrieve the remaining results, make another call with the returned NextToken value. This value can be between 1 and 200.

pub fn filters(&self) -> Option<&[Filter]>

One or more filters.

• create-time - The time the launch template version was created.

• ebs-optimized - A boolean that indicates whether the instance is optimized for Amazon EBS I/O.

• http-endpoint - Indicates whether the HTTP metadata endpoint on your instances is enabled (enabled | disabled).

• http-protocol-ipv4 - Indicates whether the IPv4 endpoint for the instance metadata service is enabled (enabled | disabled).

• host-resource-group-arn - The ARN of the host resource group in which to launch the instances.

• http-tokens - The state of token usage for your instance metadata requests (optional | required).

• iam-instance-profile - The ARN of the IAM instance profile.

• image-id - The ID of the AMI.

• instance-type - The instance type.

• is-default-version - A boolean that indicates whether the launch template version is the default version.

• kernel-id - The kernel ID.

• license-configuration-arn - The ARN of the license configuration.

• network-card-index - The index of the network card.

• ram-disk-id - The RAM disk ID.

Trait Implementations

impl Clone for DescribeLaunchTemplateVersionsInput

fn clone(&self) -> DescribeLaunchTemplateVersionsInput

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DescribeLaunchTemplateVersionsInput

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq<DescribeLaunchTemplateVersionsInput> for DescribeLaunchTemplateVersionsInput

fn eq(&self, other: &DescribeLaunchTemplateVersionsInput) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for DescribeLaunchTemplateVersionsInput