Struct aws_manager::cloudformation::Stack

pub struct Stack {
    pub name: String,
    pub id: String,
    pub status: StackStatus,
    pub outputs: Option<Vec<Output>>,
}

Represents the CloudFormation stack.

Fields

name: String

id: String

status: StackStatus

outputs: Option<Vec<Output>>

Implementations

impl Stack

pub fn new(
    name: &str,
    id: &str,
    status: StackStatus,
    outputs: Option<Vec<Output>>
) -> Self

Examples found in repository

src/cloudformation.rs (lines 71-76)

    pub async fn create_stack(
        &self,
        stack_name: &str,
        capabilities: Option<Vec<Capability>>,
        on_failure: OnFailure,
        template_body: &str,
        tags: Option<Vec<Tag>>,
        parameters: Option<Vec<Parameter>>,
    ) -> Result<Stack> {
        log::info!("creating stack '{}'", stack_name);
        let ret = self
            .cli
            .create_stack()
            .stack_name(stack_name)
            .set_capabilities(capabilities)
            .on_failure(on_failure)
            .template_body(template_body)
            .set_tags(tags)
            .set_parameters(parameters)
            .send()
            .await;
        let resp = match ret {
            Ok(v) => v,
            Err(e) => {
                return Err(API {
                    message: format!("failed create_stack {:?}", e),
                    is_retryable: is_error_retryable(&e),
                });
            }
        };

        let stack_id = resp.stack_id().unwrap();
        log::info!("created stack '{}' with '{}'", stack_name, stack_id);
        Ok(Stack::new(
            stack_name,
            stack_id,
            StackStatus::CreateInProgress,
            None,
        ))
    }

    /// Deletes a CloudFormation stack.
    /// The separate caller is expected to poll the status asynchronously.
    pub async fn delete_stack(&self, stack_name: &str) -> Result<Stack> {
        log::info!("deleting stack '{}'", stack_name);
        let ret = self.cli.delete_stack().stack_name(stack_name).send().await;
        match ret {
            Ok(_) => {}
            Err(e) => {
                if !is_error_delete_stack_does_not_exist(&e) {
                    return Err(API {
                        message: format!("failed schedule_key_deletion {:?}", e),
                        is_retryable: is_error_retryable(&e),
                    });
                }
                log::warn!("stack already deleted so returning DeleteComplete status (original error '{}')", e);
                return Ok(Stack::new(
                    stack_name,
                    "",
                    StackStatus::DeleteComplete,
                    None,
                ));
            }
        };

        Ok(Stack::new(
            stack_name,
            "",
            StackStatus::DeleteInProgress,
            None,
        ))
    }

    /// Polls CloudFormation stack status.
    pub async fn poll_stack(
        &self,
        stack_name: &str,
        desired_status: StackStatus,
        timeout: Duration,
        interval: Duration,
    ) -> Result<Stack> {
        log::info!(
            "polling stack '{}' with desired status {:?} for timeout {:?} and interval {:?}",
            stack_name,
            desired_status,
            timeout,
            interval,
        );

        let start = Instant::now();
        let mut cnt: u128 = 0;
        loop {
            let elapsed = start.elapsed();
            if elapsed.gt(&timeout) {
                break;
            }

            let itv = {
                if cnt == 0 {
                    // first poll with no wait
                    Duration::from_secs(1)
                } else {
                    interval
                }
            };
            sleep(itv).await;

            let ret = self
                .cli
                .describe_stacks()
                .stack_name(stack_name)
                .send()
                .await;
            let stacks = match ret {
                Ok(v) => v.stacks,
                Err(e) => {
                    // CFN should fail for non-existing stack, instead of returning 0 stack
                    if is_error_describe_stacks_does_not_exist(&e)
                        && desired_status.eq(&StackStatus::DeleteComplete)
                    {
                        log::info!("stack already deleted as desired");
                        return Ok(Stack::new(stack_name, "", desired_status, None));
                    }
                    return Err(API {
                        message: format!("failed describe_stacks {:?}", e),
                        is_retryable: is_error_retryable(&e),
                    });
                }
            };
            let stacks = stacks.unwrap();
            if stacks.len() != 1 {
                // CFN should fail for non-existing stack, instead of returning 0 stack
                return Err(Other {
                    message: String::from("failed to find stack"),
                    is_retryable: false,
                });
            }

            let stack = stacks.get(0).unwrap();
            let current_id = stack.stack_id().unwrap();
            let current_stack_status = stack.stack_status().unwrap();
            log::info!(
                "poll (current stack status {:?}, elapsed {:?})",
                current_stack_status,
                elapsed
            );

            if desired_status.ne(&StackStatus::DeleteComplete)
                && current_stack_status.eq(&StackStatus::DeleteComplete)
            {
                return Err(Other {
                    message: String::from("stack create/update failed thus deleted"),
                    is_retryable: false,
                });
            }

            if desired_status.eq(&StackStatus::CreateComplete)
                && current_stack_status.eq(&StackStatus::CreateFailed)
            {
                return Err(Other {
                    message: String::from("stack create failed"),
                    is_retryable: false,
                });
            }

            if desired_status.eq(&StackStatus::DeleteComplete)
                && current_stack_status.eq(&StackStatus::DeleteFailed)
            {
                return Err(Other {
                    message: String::from("stack delete failed"),
                    is_retryable: false,
                });
            }

            if current_stack_status.eq(&desired_status) {
                let outputs = if let Some(outputs) = stack.outputs() {
                    Some(Vec::from(outputs))
                } else {
                    None
                };
                return Ok(Stack::new(
                    stack_name,
                    current_id,
                    current_stack_status.clone(),
                    outputs,
                ));
            }

            cnt += 1;
        }

        Err(Other {
            message: format!("failed to poll stack {} in time", stack_name),
            is_retryable: true,
        })
    }

Trait Implementations

impl Debug for Stack

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

Formats the value using the given formatter.