Struct aws_sdk_ec2::model::NatGateway

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

Describes a NAT gateway.

Implementations

impl NatGateway

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

The date and time the NAT gateway was created.

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

The date and time the NAT gateway was deleted, if applicable.

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

If the NAT gateway could not be created, specifies the error code for the failure. (InsufficientFreeAddressesInSubnet | Gateway.NotAttached | InvalidAllocationID.NotFound | Resource.AlreadyAssociated | InternalError | InvalidSubnetID.NotFound)

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

If the NAT gateway could not be created, specifies the error message for the failure, that corresponds to the error code.

• For InsufficientFreeAddressesInSubnet: "Subnet has insufficient free addresses to create this NAT gateway"

• For Gateway.NotAttached: "Network vpc-xxxxxxxx has no Internet gateway attached"

• For InvalidAllocationID.NotFound: "Elastic IP address eipalloc-xxxxxxxx could not be associated with this NAT gateway"

• For Resource.AlreadyAssociated: "Elastic IP address eipalloc-xxxxxxxx is already associated"

• For InternalError: "Network interface eni-xxxxxxxx, created and used internally by this NAT gateway is in an invalid state. Please try again."

• For InvalidSubnetID.NotFound: "The specified subnet subnet-xxxxxxxx does not exist or could not be found."

pub fn nat_gateway_addresses(&self) -> Option<&[NatGatewayAddress]>

Information about the IP addresses and network interface associated with the NAT gateway.

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

The ID of the NAT gateway.

pub fn provisioned_bandwidth(&self) -> Option<&ProvisionedBandwidth>

Reserved. If you need to sustain traffic greater than the documented limits, contact us through the Support Center.

pub fn state(&self) -> Option<&NatGatewayState>

The state of the NAT gateway.

• pending: The NAT gateway is being created and is not ready to process traffic.

• failed: The NAT gateway could not be created. Check the failureCode and failureMessage fields for the reason.

• available: The NAT gateway is able to process traffic. This status remains until you delete the NAT gateway, and does not indicate the health of the NAT gateway.

• deleting: The NAT gateway is in the process of being terminated and may still be processing traffic.

• deleted: The NAT gateway has been terminated and is no longer processing traffic.

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

The ID of the subnet in which the NAT gateway is located.

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

The ID of the VPC in which the NAT gateway is located.

pub fn tags(&self) -> Option<&[Tag]>

The tags for the NAT gateway.

pub fn connectivity_type(&self) -> Option<&ConnectivityType>

Indicates whether the NAT gateway supports public or private connectivity.

impl NatGateway

pub fn builder() -> Builder

Creates a new builder-style object to manufacture NatGateway.

Examples found in repository

src/xml_deser.rs (line 28643)

pub fn deser_structure_crate_model_nat_gateway(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::NatGateway, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::NatGateway::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("createTime") /* CreateTime com.amazonaws.ec2#NatGateway$CreateTime */ =>  {
                let var_1194 =
                    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_create_time(var_1194);
            }
            ,
            s if s.matches("deleteTime") /* DeleteTime com.amazonaws.ec2#NatGateway$DeleteTime */ =>  {
                let var_1195 =
                    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_delete_time(var_1195);
            }
            ,
            s if s.matches("failureCode") /* FailureCode com.amazonaws.ec2#NatGateway$FailureCode */ =>  {
                let var_1196 =
                    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_failure_code(var_1196);
            }
            ,
            s if s.matches("failureMessage") /* FailureMessage com.amazonaws.ec2#NatGateway$FailureMessage */ =>  {
                let var_1197 =
                    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_failure_message(var_1197);
            }
            ,
            s if s.matches("natGatewayAddressSet") /* NatGatewayAddresses com.amazonaws.ec2#NatGateway$NatGatewayAddresses */ =>  {
                let var_1198 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_nat_gateway_address_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_nat_gateway_addresses(var_1198);
            }
            ,
            s if s.matches("natGatewayId") /* NatGatewayId com.amazonaws.ec2#NatGateway$NatGatewayId */ =>  {
                let var_1199 =
                    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_nat_gateway_id(var_1199);
            }
            ,
            s if s.matches("provisionedBandwidth") /* ProvisionedBandwidth com.amazonaws.ec2#NatGateway$ProvisionedBandwidth */ =>  {
                let var_1200 =
                    Some(
                        crate::xml_deser::deser_structure_crate_model_provisioned_bandwidth(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_provisioned_bandwidth(var_1200);
            }
            ,
            s if s.matches("state") /* State com.amazonaws.ec2#NatGateway$State */ =>  {
                let var_1201 =
                    Some(
                        Result::<crate::model::NatGatewayState, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::NatGatewayState::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_state(var_1201);
            }
            ,
            s if s.matches("subnetId") /* SubnetId com.amazonaws.ec2#NatGateway$SubnetId */ =>  {
                let var_1202 =
                    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_subnet_id(var_1202);
            }
            ,
            s if s.matches("vpcId") /* VpcId com.amazonaws.ec2#NatGateway$VpcId */ =>  {
                let var_1203 =
                    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_vpc_id(var_1203);
            }
            ,
            s if s.matches("tagSet") /* Tags com.amazonaws.ec2#NatGateway$Tags */ =>  {
                let var_1204 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_ec2_tag_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_tags(var_1204);
            }
            ,
            s if s.matches("connectivityType") /* ConnectivityType com.amazonaws.ec2#NatGateway$ConnectivityType */ =>  {
                let var_1205 =
                    Some(
                        Result::<crate::model::ConnectivityType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ConnectivityType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_connectivity_type(var_1205);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for NatGateway

fn clone(&self) -> NatGateway

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NatGateway

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

Formats the value using the given formatter.

impl PartialEq<NatGateway> for NatGateway

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