ic-backup 0.6.0

Host-side snapshot backup and same-release recovery for Internet Computer canisters
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

//! Passive whole-selection consistency fixtures; no management or application backend.

use crate::model::consistency::*;
use crate::test_support::membership::hash;

pub fn parameters(guarantee: ConsistencyGuaranteeRecord) -> ConsistencyRequestInput {
    ConsistencyRequestInput {
        operation_sequence: 7,
        challenge: hash("12"),
        boundary: ConsistencyBoundary::BeforeCapture,
        expected_fence: match guarantee {
            ConsistencyGuaranteeRecord::PerCanister => None,
            ConsistencyGuaranteeRecord::ApplicationCoordinated => Some(ApplicationFenceBinding {
                identity: hash("56"),
                membership_revision: hash("78"),
            }),
        },
        max_remote_observations: 1,
    }
}
pub fn fence() -> ApplicationFenceEvidence {
    ApplicationFenceEvidence {
        state: ApplicationFenceState::Active,
        identity: hash("56"),
        membership_revision: hash("78"),
        writes: hash("90"),
        membership: hash("ab"),
        timers: hash("bc"),
        external_work: hash("cd"),
        drained_work: hash("de"),
    }
}
pub fn input(request: &ConsistencyRequest<'_>) -> ConsistencyObservationInput {
    let context = crate::model::operation_plan::PlanContextRecord::new(
        &crate::model::operation_plan::PlanContextRequest {
            network: request.binding().network().into(),
            caller: request.binding().caller().into(),
            release: request.binding().release().into(),
        },
    )
    .unwrap();
    ConsistencyObservationInput {
        request: request.digest(),
        context,
        inventory: request.inventory().clone(),
        targets: request
            .selected_targets()
            .iter()
            .map(|target| TargetCaptureEvidence {
                target: target.clone(),
                state: CaptureState::Stopped,
                stopped_and_drained: hash("ef"),
            })
            .collect(),
        membership_revision: Some(hash("78")),
        consistency: match request.requirement().guarantee() {
            ConsistencyGuaranteeRecord::PerCanister => ConsistencyEvidence::PerCanister,
            ConsistencyGuaranteeRecord::ApplicationCoordinated => {
                ConsistencyEvidence::ApplicationCoordinated(Box::new(fence()))
            }
        },
        evidence: hash("34"),
        remote_observations: 1,
    }
}