Struct aws_sdk_elasticache::model::NodeGroupConfiguration

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

Node group (shard) configuration options. Each node group (shard) configuration has the following: Slots, PrimaryAvailabilityZone, ReplicaAvailabilityZones, ReplicaCount.

Implementations

impl NodeGroupConfiguration

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

Either the ElastiCache for Redis supplied 4-digit id or a user supplied id for the node group these configuration values apply to.

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

A string that specifies the keyspace for a particular node group. Keyspaces range from 0 to 16,383. The string is in the format startkey-endkey.

Example: "0-3999"

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

The number of read replica nodes in this node group (shard).

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

The Availability Zone where the primary node of this node group (shard) is launched.

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

A list of Availability Zones to be used for the read replicas. The number of Availability Zones in this list must match the value of ReplicaCount or ReplicasPerNodeGroup if not specified.

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

The outpost ARN of the primary node.

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

The outpost ARN of the node replicas.

impl NodeGroupConfiguration

pub fn builder() -> Builder

Creates a new builder-style object to manufacture NodeGroupConfiguration.

Examples found in repository

src/xml_deser.rs (line 11612)

pub fn deser_structure_crate_model_node_group_configuration(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::NodeGroupConfiguration, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::NodeGroupConfiguration::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("NodeGroupId") /* NodeGroupId com.amazonaws.elasticache#NodeGroupConfiguration$NodeGroupId */ =>  {
                let var_498 =
                    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_node_group_id(var_498);
            }
            ,
            s if s.matches("Slots") /* Slots com.amazonaws.elasticache#NodeGroupConfiguration$Slots */ =>  {
                let var_499 =
                    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_slots(var_499);
            }
            ,
            s if s.matches("ReplicaCount") /* ReplicaCount com.amazonaws.elasticache#NodeGroupConfiguration$ReplicaCount */ =>  {
                let var_500 =
                    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.elasticache#IntegerOptional`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_replica_count(var_500);
            }
            ,
            s if s.matches("PrimaryAvailabilityZone") /* PrimaryAvailabilityZone com.amazonaws.elasticache#NodeGroupConfiguration$PrimaryAvailabilityZone */ =>  {
                let var_501 =
                    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_primary_availability_zone(var_501);
            }
            ,
            s if s.matches("ReplicaAvailabilityZones") /* ReplicaAvailabilityZones com.amazonaws.elasticache#NodeGroupConfiguration$ReplicaAvailabilityZones */ =>  {
                let var_502 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticache_availability_zones_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_replica_availability_zones(var_502);
            }
            ,
            s if s.matches("PrimaryOutpostArn") /* PrimaryOutpostArn com.amazonaws.elasticache#NodeGroupConfiguration$PrimaryOutpostArn */ =>  {
                let var_503 =
                    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_primary_outpost_arn(var_503);
            }
            ,
            s if s.matches("ReplicaOutpostArns") /* ReplicaOutpostArns com.amazonaws.elasticache#NodeGroupConfiguration$ReplicaOutpostArns */ =>  {
                let var_504 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticache_outpost_arns_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_replica_outpost_arns(var_504);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for NodeGroupConfiguration

fn clone(&self) -> NodeGroupConfiguration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeGroupConfiguration

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

Formats the value using the given formatter.

impl PartialEq<NodeGroupConfiguration> for NodeGroupConfiguration

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