canic-cli 0.35.11

Operator CLI for Canic fleet backup and restore workflows
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
102
103

use canic_backup::{
    execution::{
        BackupExecutionJournal, BackupExecutionOperationState, BackupExecutionResumeSummary,
    },
    plan::{
        AuthorityEvidence, BackupOperationKind, BackupPlan, BackupScopeKind,
        ControlAuthoritySource, SnapshotReadAuthoritySource,
    },
};

pub(super) fn execution_layout_status(
    journal: &BackupExecutionJournal,
    has_manifest: bool,
) -> String {
    let summary = journal.resume_summary();
    if has_manifest && execution_is_complete(&summary) {
        "complete".to_string()
    } else if summary.failed_operations > 0 {
        "failed".to_string()
    } else if journal.preflight_accepted || summary.completed_operations > 0 {
        "running".to_string()
    } else {
        "dry-run".to_string()
    }
}

pub(super) const fn execution_is_complete(execution: &BackupExecutionResumeSummary) -> bool {
    execution.completed_operations + execution.skipped_operations == execution.total_operations
}

pub(super) fn backup_scope_label(plan: &BackupPlan) -> String {
    match plan.selected_scope_kind {
        BackupScopeKind::NonRootFleet => "non-root-fleet".to_string(),
        BackupScopeKind::Subtree => plan
            .selected_subtree_root
            .as_ref()
            .map_or_else(|| "subtree".to_string(), |root| format!("subtree:{root}")),
        BackupScopeKind::Member => plan
            .selected_subtree_root
            .as_ref()
            .map_or_else(|| "member".to_string(), |root| format!("member:{root}")),
        BackupScopeKind::MaintenanceRoot => "maintenance-root".to_string(),
    }
}

pub(super) fn format_authority(source: &str, evidence: &AuthorityEvidence) -> String {
    format!("{source}/{}", authority_evidence_label(evidence))
}

pub(super) const fn control_authority_source_label(source: &ControlAuthoritySource) -> &str {
    match source {
        ControlAuthoritySource::Unknown => "unknown",
        ControlAuthoritySource::RootController => "root-controller",
        ControlAuthoritySource::OperatorController => "operator-controller",
        ControlAuthoritySource::AlternateController { .. } => "alternate-controller",
    }
}

pub(super) const fn snapshot_read_authority_source_label(
    source: &SnapshotReadAuthoritySource,
) -> &str {
    match source {
        SnapshotReadAuthoritySource::Unknown => "unknown",
        SnapshotReadAuthoritySource::OperatorController => "operator-controller",
        SnapshotReadAuthoritySource::SnapshotVisibility => "snapshot-visibility",
        SnapshotReadAuthoritySource::RootConfiguredRead => "root-configured-read",
        SnapshotReadAuthoritySource::RootMediatedTransfer => "root-mediated-transfer",
    }
}

const fn authority_evidence_label(evidence: &AuthorityEvidence) -> &str {
    match evidence {
        AuthorityEvidence::Proven => "proven",
        AuthorityEvidence::Declared => "declared",
        AuthorityEvidence::Unknown => "unknown",
    }
}

pub(super) const fn operation_kind_label(kind: &BackupOperationKind) -> &str {
    match kind {
        BackupOperationKind::ValidateTopology => "validate-topology",
        BackupOperationKind::ValidateControlAuthority => "validate-control-authority",
        BackupOperationKind::ValidateSnapshotReadAuthority => "validate-snapshot-read-authority",
        BackupOperationKind::ValidateQuiescencePolicy => "validate-quiescence-policy",
        BackupOperationKind::Stop => "stop",
        BackupOperationKind::CreateSnapshot => "create-snapshot",
        BackupOperationKind::Start => "start",
        BackupOperationKind::DownloadSnapshot => "download-snapshot",
        BackupOperationKind::VerifyArtifact => "verify-artifact",
        BackupOperationKind::FinalizeManifest => "finalize-manifest",
    }
}

pub(super) const fn operation_state_label(state: &BackupExecutionOperationState) -> &str {
    match state {
        BackupExecutionOperationState::Ready => "ready",
        BackupExecutionOperationState::Pending => "pending",
        BackupExecutionOperationState::Blocked => "blocked",
        BackupExecutionOperationState::Completed => "completed",
        BackupExecutionOperationState::Failed => "failed",
        BackupExecutionOperationState::Skipped => "skipped",
    }
}