Struct aws_sdk_cloudformation::model::StackSetDriftDetectionDetails

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

Detailed information about the drift status of the stack set.

For stack sets, contains information about the last completed drift operation performed on the stack set. Information about drift operations in-progress isn't included.

For stack set operations, includes information about drift operations currently being performed on the stack set.

For more information, see Detecting unmanaged changes in stack sets in the CloudFormation User Guide.

Implementations

impl StackSetDriftDetectionDetails

pub fn drift_status(&self) -> Option<&StackSetDriftStatus>

Status of the stack set's actual configuration compared to its expected template and parameter configuration. A stack set is considered to have drifted if one or more of its stack instances have drifted from their expected template and parameter configuration.

• DRIFTED: One or more of the stack instances belonging to the stack set stack differs from the expected template and parameter configuration. A stack instance is considered to have drifted if one or more of the resources in the associated stack have drifted.

• NOT_CHECKED: CloudFormation hasn't checked the stack set for drift.

• IN_SYNC: All of the stack instances belonging to the stack set stack match from the expected template and parameter configuration.

pub fn drift_detection_status(&self) -> Option<&StackSetDriftDetectionStatus>

The status of the stack set drift detection operation.

• COMPLETED: The drift detection operation completed without failing on any stack instances.

• FAILED: The drift detection operation exceeded the specified failure tolerance.

• PARTIAL_SUCCESS: The drift detection operation completed without exceeding the failure tolerance for the operation.

• IN_PROGRESS: The drift detection operation is currently being performed.

• STOPPED: The user has canceled the drift detection operation.

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

Most recent time when CloudFormation performed a drift detection operation on the stack set. This value will be NULL for any stack set on which drift detection hasn't yet been performed.

pub fn total_stack_instances_count(&self) -> i32

The total number of stack instances belonging to this stack set.

The total number of stack instances is equal to the total of:

• Stack instances that match the stack set configuration.

• Stack instances that have drifted from the stack set configuration.

• Stack instances where the drift detection operation has failed.

• Stack instances currently being checked for drift.

pub fn drifted_stack_instances_count(&self) -> i32

The number of stack instances that have drifted from the expected template and parameter configuration of the stack set. A stack instance is considered to have drifted if one or more of the resources in the associated stack don't match their expected configuration.

pub fn in_sync_stack_instances_count(&self) -> i32

The number of stack instances which match the expected template and parameter configuration of the stack set.

pub fn in_progress_stack_instances_count(&self) -> i32

The number of stack instances that are currently being checked for drift.

pub fn failed_stack_instances_count(&self) -> i32

The number of stack instances for which the drift detection operation failed.

impl StackSetDriftDetectionDetails

pub fn builder() -> Builder

Creates a new builder-style object to manufacture StackSetDriftDetectionDetails.

Examples found in repository

src/xml_deser.rs (line 7608)

pub fn deser_structure_crate_model_stack_set_drift_detection_details(
    decoder: &mut aws_smithy_xml::decode::ScopedDecoder,
) -> Result<crate::model::StackSetDriftDetectionDetails, aws_smithy_xml::decode::XmlDecodeError> {
    #[allow(unused_mut)]
    let mut builder = crate::model::StackSetDriftDetectionDetails::builder();
    while let Some(mut tag) = decoder.next_tag() {
        match tag.start_el() {
            s if s.matches("DriftStatus") /* DriftStatus com.amazonaws.cloudformation#StackSetDriftDetectionDetails$DriftStatus */ =>  {
                let var_323 =
                    Some(
                        Result::<crate::model::StackSetDriftStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::StackSetDriftStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_drift_status(var_323);
            }
            ,
            s if s.matches("DriftDetectionStatus") /* DriftDetectionStatus com.amazonaws.cloudformation#StackSetDriftDetectionDetails$DriftDetectionStatus */ =>  {
                let var_324 =
                    Some(
                        Result::<crate::model::StackSetDriftDetectionStatus, aws_smithy_xml::decode::XmlDecodeError>::Ok(
                            crate::model::StackSetDriftDetectionStatus::from(
                                aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
                            )
                        )
                        ?
                    )
                ;
                builder = builder.set_drift_detection_status(var_324);
            }
            ,
            s if s.matches("LastDriftCheckTimestamp") /* LastDriftCheckTimestamp com.amazonaws.cloudformation#StackSetDriftDetectionDetails$LastDriftCheckTimestamp */ =>  {
                let var_325 =
                    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.cloudformation#Timestamp`)"))
                        ?
                    )
                ;
                builder = builder.set_last_drift_check_timestamp(var_325);
            }
            ,
            s if s.matches("TotalStackInstancesCount") /* TotalStackInstancesCount com.amazonaws.cloudformation#StackSetDriftDetectionDetails$TotalStackInstancesCount */ =>  {
                let var_326 =
                    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.cloudformation#TotalStackInstancesCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_total_stack_instances_count(var_326);
            }
            ,
            s if s.matches("DriftedStackInstancesCount") /* DriftedStackInstancesCount com.amazonaws.cloudformation#StackSetDriftDetectionDetails$DriftedStackInstancesCount */ =>  {
                let var_327 =
                    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.cloudformation#DriftedStackInstancesCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_drifted_stack_instances_count(var_327);
            }
            ,
            s if s.matches("InSyncStackInstancesCount") /* InSyncStackInstancesCount com.amazonaws.cloudformation#StackSetDriftDetectionDetails$InSyncStackInstancesCount */ =>  {
                let var_328 =
                    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.cloudformation#InSyncStackInstancesCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_in_sync_stack_instances_count(var_328);
            }
            ,
            s if s.matches("InProgressStackInstancesCount") /* InProgressStackInstancesCount com.amazonaws.cloudformation#StackSetDriftDetectionDetails$InProgressStackInstancesCount */ =>  {
                let var_329 =
                    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.cloudformation#InProgressStackInstancesCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_in_progress_stack_instances_count(var_329);
            }
            ,
            s if s.matches("FailedStackInstancesCount") /* FailedStackInstancesCount com.amazonaws.cloudformation#StackSetDriftDetectionDetails$FailedStackInstancesCount */ =>  {
                let var_330 =
                    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.cloudformation#FailedStackInstancesCount`)"))
                        }
                        ?
                    )
                ;
                builder = builder.set_failed_stack_instances_count(var_330);
            }
            ,
            _ => {}
        }
    }
    Ok(builder.build())
}

Trait Implementations

impl Clone for StackSetDriftDetectionDetails

fn clone(&self) -> StackSetDriftDetectionDetails

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StackSetDriftDetectionDetails

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

Formats the value using the given formatter.

impl PartialEq<StackSetDriftDetectionDetails> for StackSetDriftDetectionDetails

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