Struct aws_sdk_elasticache::model::UpdateAction

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

The status of the service update for a specific replication group

Implementations

impl UpdateAction

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

The ID of the replication group

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

The ID of the cache cluster

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

The unique ID of the service update

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

The date the update is first available

pub fn service_update_severity(&self) -> Option<&ServiceUpdateSeverity>

The severity of the service update

pub fn service_update_status(&self) -> Option<&ServiceUpdateStatus>

The status of the service update

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

The recommended date to apply the service update to ensure compliance. For information on compliance, see Self-Service Security Updates for Compliance.

pub fn service_update_type(&self) -> Option<&ServiceUpdateType>

Reflects the nature of the service update

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

The date that the service update is available to a replication group

pub fn update_action_status(&self) -> Option<&UpdateActionStatus>

The status of the update action

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

The progress of the service update on the replication group

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

The date when the UpdateActionStatus was last modified

pub fn sla_met(&self) -> Option<&SlaMet>

If yes, all nodes in the replication group have been updated by the recommended apply-by date. If no, at least one node in the replication group have not been updated by the recommended apply-by date. If N/A, the replication group was created after the recommended apply-by date.

pub fn node_group_update_status(&self) -> Option<&[NodeGroupUpdateStatus]>

The status of the service update on the node group

pub fn cache_node_update_status(&self) -> Option<&[CacheNodeUpdateStatus]>

The status of the service update on the cache node

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

The estimated length of time for the update to complete

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

The Elasticache engine to which the update applies. Either Redis or Memcached

impl UpdateAction

pub fn builder() -> Builder

Creates a new builder-style object to manufacture UpdateAction.

Examples found in repository

src/xml_deser.rs (line 10086)

pub fn deser_structure_crate_model_update_action(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::UpdateAction, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::UpdateAction::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("ReplicationGroupId") /* ReplicationGroupId com.amazonaws.elasticache#UpdateAction$ReplicationGroupId */ =>  {
                let var_408 =
                    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_replication_group_id(var_408);
            }
            ,
            s if s.matches("CacheClusterId") /* CacheClusterId com.amazonaws.elasticache#UpdateAction$CacheClusterId */ =>  {
                let var_409 =
                    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_cache_cluster_id(var_409);
            }
            ,
            s if s.matches("ServiceUpdateName") /* ServiceUpdateName com.amazonaws.elasticache#UpdateAction$ServiceUpdateName */ =>  {
                let var_410 =
                    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_service_update_name(var_410);
            }
            ,
            s if s.matches("ServiceUpdateReleaseDate") /* ServiceUpdateReleaseDate com.amazonaws.elasticache#UpdateAction$ServiceUpdateReleaseDate */ =>  {
                let var_411 =
                    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.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_release_date(var_411);
            }
            ,
            s if s.matches("ServiceUpdateSeverity") /* ServiceUpdateSeverity com.amazonaws.elasticache#UpdateAction$ServiceUpdateSeverity */ =>  {
                let var_412 =
                    Some(
                        Result::<crate::model::ServiceUpdateSeverity, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateSeverity::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_severity(var_412);
            }
            ,
            s if s.matches("ServiceUpdateStatus") /* ServiceUpdateStatus com.amazonaws.elasticache#UpdateAction$ServiceUpdateStatus */ =>  {
                let var_413 =
                    Some(
                        Result::<crate::model::ServiceUpdateStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_status(var_413);
            }
            ,
            s if s.matches("ServiceUpdateRecommendedApplyByDate") /* ServiceUpdateRecommendedApplyByDate com.amazonaws.elasticache#UpdateAction$ServiceUpdateRecommendedApplyByDate */ =>  {
                let var_414 =
                    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.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_service_update_recommended_apply_by_date(var_414);
            }
            ,
            s if s.matches("ServiceUpdateType") /* ServiceUpdateType com.amazonaws.elasticache#UpdateAction$ServiceUpdateType */ =>  {
                let var_415 =
                    Some(
                        Result::<crate::model::ServiceUpdateType, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::ServiceUpdateType::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_service_update_type(var_415);
            }
            ,
            s if s.matches("UpdateActionAvailableDate") /* UpdateActionAvailableDate com.amazonaws.elasticache#UpdateAction$UpdateActionAvailableDate */ =>  {
                let var_416 =
                    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.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_update_action_available_date(var_416);
            }
            ,
            s if s.matches("UpdateActionStatus") /* UpdateActionStatus com.amazonaws.elasticache#UpdateAction$UpdateActionStatus */ =>  {
                let var_417 =
                    Some(
                        Result::<crate::model::UpdateActionStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::UpdateActionStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_update_action_status(var_417);
            }
            ,
            s if s.matches("NodesUpdated") /* NodesUpdated com.amazonaws.elasticache#UpdateAction$NodesUpdated */ =>  {
                let var_418 =
                    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_nodes_updated(var_418);
            }
            ,
            s if s.matches("UpdateActionStatusModifiedDate") /* UpdateActionStatusModifiedDate com.amazonaws.elasticache#UpdateAction$UpdateActionStatusModifiedDate */ =>  {
                let var_419 =
                    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.elasticache#TStamp`)"))
                        ?
                    )
                ;
                builder = builder.set_update_action_status_modified_date(var_419);
            }
            ,
            s if s.matches("SlaMet") /* SlaMet com.amazonaws.elasticache#UpdateAction$SlaMet */ =>  {
                let var_420 =
                    Some(
                        Result::<crate::model::SlaMet, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::SlaMet::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_sla_met(var_420);
            }
            ,
            s if s.matches("NodeGroupUpdateStatus") /* NodeGroupUpdateStatus com.amazonaws.elasticache#UpdateAction$NodeGroupUpdateStatus */ =>  {
                let var_421 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticache_node_group_update_status_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_node_group_update_status(var_421);
            }
            ,
            s if s.matches("CacheNodeUpdateStatus") /* CacheNodeUpdateStatus com.amazonaws.elasticache#UpdateAction$CacheNodeUpdateStatus */ =>  {
                let var_422 =
                    Some(
                        crate::xml_deser::deser_list_com_amazonaws_elasticache_cache_node_update_status_list(&mut tag)
                        ?
                    )
                ;
                builder = builder.set_cache_node_update_status(var_422);
            }
            ,
            s if s.matches("EstimatedUpdateTime") /* EstimatedUpdateTime com.amazonaws.elasticache#UpdateAction$EstimatedUpdateTime */ =>  {
                let var_423 =
                    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_estimated_update_time(var_423);
            }
            ,
            s if s.matches("Engine") /* Engine com.amazonaws.elasticache#UpdateAction$Engine */ =>  {
                let var_424 =
                    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_engine(var_424);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for UpdateAction

fn clone(&self) -> UpdateAction

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UpdateAction

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

Formats the value using the given formatter.

impl PartialEq<UpdateAction> for UpdateAction

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