canic-host 0.110.30

Host-side App build and desired-state Fleet reconciliation library for Canic workspaces
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Module: fleet_ensure::policy::continuation_forecast
//!
//! Responsibility: project known continuation work from one immutable review.
//! Boundary: no live reads, quote completion, persistent changes or effect admission.

use crate::fleet_ensure::{
    model::{
        CanisterDisposition, CurrentFleetProtocolAction, EnsureAction, FleetEnsurePlan,
        FleetEnsurePlanScope, FleetEnsureReport,
    },
    view::continuation::{
        ContinuationAuthority, ContinuationDiscovery, ContinuationForecast, ContinuationImport,
        ContinuationImportState, DependentPoolFunding,
    },
};

/// Explain the reviewed ceiling separately from dependent imports and funding.
#[must_use]
pub fn forecast(report: &FleetEnsureReport) -> ContinuationForecast {
    let plan = &report.plan;
    let complete = report.terminal && plan.scope == FleetEnsurePlanScope::Full;
    let mut result = ContinuationForecast {
        authority: if complete {
            ContinuationAuthority::Complete
        } else if plan.continuation.is_some() {
            ContinuationAuthority::WithinReviewedProtocolBounds
        } else {
            ContinuationAuthority::SeparateReview
        },
        reviewed_actions: plan
            .canisters
            .iter()
            .map(|canister| canister.actions.len())
            .sum::<usize>()
            + plan.protocol_actions.len(),
        maximum_successor_actions: plan
            .continuation
            .as_ref()
            .map(|value| value.maximum_successor_actions),
        maximum_operator_debit_cycles: plan.conservation.maximum_operator_debit_cycles,
        imports: Vec::new(),
        dependent_funding: Vec::new(),
        requires_live_discovery: Vec::new(),
    };
    if complete {
        return result;
    }
    let awaiting_initialization = append_initialization_imports(plan, &mut result.imports);
    for action in &plan.protocol_actions {
        if let EnsureAction::FleetProtocol {
            name,
            principal,
            action,
            ..
        } = action
            && let CurrentFleetProtocolAction::ReconcilePoolAsset { request, .. } = action.as_ref()
        {
            result.imports.push(ContinuationImport {
                root: principal.clone(),
                canister: name.clone(),
                principal: Some(request.canister_id.to_text()),
                state: ContinuationImportState::ReviewedReconciliation,
            });
        }
    }
    if let Some(review) = &plan.recovery_review {
        result.dependent_funding = review
            .known_pool_funding
            .iter()
            .map(|funding| DependentPoolFunding {
                root: funding.root.clone(),
                principal: funding.principal.clone(),
                amount_cycles: funding.amount_cycles,
                ledger_fee_cycles: funding.ledger_fee_cycles,
            })
            .collect();
    }
    if awaiting_initialization
        || plan.scope != FleetEnsurePlanScope::Full
        || plan.continuation.is_some()
        || plan.recovery_review.is_some()
        || !result.imports.is_empty()
    {
        result.requires_live_discovery = vec![
            ContinuationDiscovery::PoolReadiness,
            ContinuationDiscovery::PoolFundingAndCapacity,
            ContinuationDiscovery::PublicationAndProvisioning,
        ];
    }
    result
}

fn append_initialization_imports(
    plan: &FleetEnsurePlan,
    imports: &mut Vec<ContinuationImport>,
) -> bool {
    let mut awaiting_initialization = false;
    if let Some(desired) = plan.reviewed_desired.as_ref().map(|value| value.desired()) {
        for root in desired
            .bootstrap
            .iter()
            .flat_map(|bootstrap| &bootstrap.roots)
        {
            let initializes = plan.canisters.iter().any(|canister| {
                canister.name == root.root
                    && matches!(
                        canister.disposition,
                        CanisterDisposition::Create
                            | CanisterDisposition::Replace
                            | CanisterDisposition::Reinstall
                    )
            });
            if !initializes {
                continue;
            }
            awaiting_initialization = true;
            for name in &root.canister_pool_imports {
                let principal = match plan
                    .canisters
                    .iter()
                    .find(|canister| &canister.name == name)
                {
                    Some(canister) => canister.principal.clone(),
                    None => desired
                        .canisters
                        .iter()
                        .find(|canister| &canister.name == name)
                        .and_then(|canister| canister.principal.clone()),
                };
                imports.push(ContinuationImport {
                    root: root.root.clone(),
                    canister: name.clone(),
                    principal,
                    state: ContinuationImportState::PostInitializationObservation,
                });
            }
        }
    }
    awaiting_initialization
}