Struct aws_sdk_ec2::model::LaunchTemplateSpotMarketOptions

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

The options for Spot Instances.

Implementations

impl LaunchTemplateSpotMarketOptions

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

The maximum hourly price you're willing to pay for the Spot Instances. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price.

If you specify a maximum price, your Spot Instances will be interrupted more frequently than if you do not specify this parameter.

pub fn spot_instance_type(&self) -> Option<&SpotInstanceType>

The Spot Instance request type.

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

The required duration for the Spot Instances (also known as Spot blocks), in minutes. This value must be a multiple of 60 (60, 120, 180, 240, 300, or 360).

pub fn valid_until(&self) -> Option<&DateTime>

The end date of the request. For a one-time request, the request remains active until all instances launch, the request is canceled, or this date is reached. If the request is persistent, it remains active until it is canceled or this date and time is reached.

pub fn instance_interruption_behavior(
    &self
) -> Option<&InstanceInterruptionBehavior>

The behavior when a Spot Instance is interrupted.

impl LaunchTemplateSpotMarketOptions

pub fn builder() -> Builder

Creates a new builder-style object to manufacture LaunchTemplateSpotMarketOptions.

Examples found in repository

src/xml_deser.rs (line 61694)

pub fn deser_structure_crate_model_launch_template_spot_market_options(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::LaunchTemplateSpotMarketOptions, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::LaunchTemplateSpotMarketOptions::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("maxPrice") /* MaxPrice com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$MaxPrice */ =>  {
                let var_3017 =
                    Some(
                        Result::<std::string::String, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            .into()
                        )
                        ?
                    )
                ;
                builder = builder.set_max_price(var_3017);
            }
            ,
            s if s.matches("spotInstanceType") /* SpotInstanceType com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$SpotInstanceType */ =>  {
                let var_3018 =
                    Some(
                        Result::<crate::model::SpotInstanceType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::SpotInstanceType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_spot_instance_type(var_3018);
            }
            ,
            s if s.matches("blockDurationMinutes") /* BlockDurationMinutes com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$BlockDurationMinutes */ =>  {
                let var_3019 =
                    Some(
                         {
                            <i32 as aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                            .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (integer: `com.amazonaws.ec2#Integer`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_block_duration_minutes(var_3019);
            }
            ,
            s if s.matches("validUntil") /* ValidUntil com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$ValidUntil */ =>  {
                let var_3020 =
                    Some(
                        aws_smithy_types::DateTime::from_str(
                            aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            , aws_smithy_types::date_time::Format::DateTime
                        )
                        .map_err(|_|aws_smithy_xml::decode::XmlDecodeError::custom("expected (timestamp: `com.amazonaws.ec2#DateTime`)"))
                        ?
                    )
                ;
                builder = builder.set_valid_until(var_3020);
            }
            ,
            s if s.matches("instanceInterruptionBehavior") /* InstanceInterruptionBehavior com.amazonaws.ec2#LaunchTemplateSpotMarketOptions$InstanceInterruptionBehavior */ =>  {
                let var_3021 =
                    Some(
                        Result::<crate::model::InstanceInterruptionBehavior, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::InstanceInterruptionBehavior::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_instance_interruption_behavior(var_3021);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for LaunchTemplateSpotMarketOptions

fn clone(&self) -> LaunchTemplateSpotMarketOptions

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LaunchTemplateSpotMarketOptions

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

Formats the value using the given formatter.

impl PartialEq<LaunchTemplateSpotMarketOptions> for LaunchTemplateSpotMarketOptions

fn eq(&self, other: &LaunchTemplateSpotMarketOptions) -> 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 LaunchTemplateSpotMarketOptions