coil-ops 0.1.0

Operations and release-management capabilities for the Coil framework.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

use std::collections::BTreeSet;
use std::time::Duration;

use coil_auth::Capability;
use coil_jobs::RetryPolicy;

use crate::error::OpsModelError;
use crate::identifiers::RecoveryWorkflowId;

use super::{RecoveryStage, RecoveryWorkflowDefinition};

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RecoveryCatalog {
    definitions: Vec<RecoveryWorkflowDefinition>,
}

impl RecoveryCatalog {
    pub fn new(definitions: Vec<RecoveryWorkflowDefinition>) -> Self {
        Self { definitions }
    }

    pub fn standard() -> Self {
        Self::new(vec![
            RecoveryWorkflowDefinition::new(
                RecoveryWorkflowId::new("recovery.customer-app.full-restore")
                    .expect("constant workflow id is valid"),
                "Full customer-app restore",
                Some(
                    "Restores source-of-truth state first, then rebuilds disposable layers and redeploys assets."
                        .to_string(),
                ),
                Capability::SystemModuleManage,
                default_recovery_retry_policy(),
                true,
                true,
                vec![
                    RecoveryStage::RestoreDatabase,
                    RecoveryStage::ReattachManagedObjectStore,
                    RecoveryStage::RestoreLocalOnlySensitive,
                    RecoveryStage::RebuildDerivedState,
                    RecoveryStage::RedeployStaticAssets,
                    RecoveryStage::ValidateReadiness,
                ],
            )
            .expect("constant recovery workflow is valid"),
            RecoveryWorkflowDefinition::new(
                RecoveryWorkflowId::new("recovery.customer-app.derived-state")
                    .expect("constant workflow id is valid"),
                "Derived-state rebuild",
                Some(
                    "Rebuilds caches, search indexes, report snapshots, and redeploys static assets without restoring source-of-truth storage."
                        .to_string(),
                ),
                Capability::SystemModuleManage,
                default_recovery_retry_policy(),
                true,
                false,
                vec![
                    RecoveryStage::RebuildDerivedState,
                    RecoveryStage::RedeployStaticAssets,
                    RecoveryStage::ValidateReadiness,
                ],
            )
            .expect("constant recovery workflow is valid"),
        ])
    }

    pub fn definitions(&self) -> &[RecoveryWorkflowDefinition] {
        &self.definitions
    }

    pub fn definition(&self, id: &RecoveryWorkflowId) -> Option<&RecoveryWorkflowDefinition> {
        self.definitions
            .iter()
            .find(|definition| &definition.id == id)
    }

    pub fn validate(&self) -> Result<(), OpsModelError> {
        let mut ids = BTreeSet::new();
        for definition in &self.definitions {
            if !ids.insert(definition.id.as_str().to_string()) {
                return Err(OpsModelError::DuplicateIdentifier {
                    kind: "recovery workflow",
                    id: definition.id.to_string(),
                });
            }
        }
        Ok(())
    }
}

impl Default for RecoveryCatalog {
    fn default() -> Self {
        Self::standard()
    }
}

fn default_recovery_retry_policy() -> RetryPolicy {
    RetryPolicy::new(3, Duration::from_secs(30), Duration::from_secs(900))
        .expect("constant recovery retry policy is valid")
}