canic-control-plane 0.93.20

Canic — a canister orchestration and management toolkit for the Internet Computer
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

use crate::ids::WasmStoreGcMode;
use canic_core::cdk::structures::{DefaultMemoryImpl, cell::Cell, memory::VirtualMemory};
use canic_core::eager_static;
use canic_core::{
    impl_storable_bounded, role_contract::allocation::memory::template::WASM_STORE_GC_STATE_ID,
};
use serde::{Deserialize, Serialize};
use std::cell::RefCell;

eager_static! {
    static WASM_STORE_GC_STATE: RefCell<
        Cell<WasmStoreGcStateRecord, VirtualMemory<DefaultMemoryImpl>>
    > = RefCell::new(Cell::init(
        canic_core::ic_memory_key!(authority = CANIC_CONTROL_PLANE_MEMORY_AUTHORITY, key = "canic.control_plane.wasm_store_gc_state.v1", ty = WasmStoreGcStateRecord, id = WASM_STORE_GC_STATE_ID),
        WasmStoreGcStateRecord::default(),
    ));
}

///
/// WasmStoreGcStateRecord
///

#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
pub struct WasmStoreGcStateRecord {
    pub mode: WasmStoreGcMode,
    pub changed_at: u64,
    pub prepared_at: Option<u64>,
    pub started_at: Option<u64>,
    pub completed_at: Option<u64>,
    pub runs_completed: u32,
}

impl WasmStoreGcStateRecord {
    pub const STATE_CONTRACT_NAME: &'static str = "WasmStoreGcStateRecord";
}

impl_storable_bounded!(WasmStoreGcStateRecord, 64, true);

///
/// WasmStoreGcStateData
///
/// Canonical local wasm-store GC-state allocation snapshot.
///

#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct WasmStoreGcStateData {
    pub record: WasmStoreGcStateRecord,
}

impl WasmStoreGcStateData {
    pub const STATE_CONTRACT_NAME: &'static str = "WasmStoreGcStateData";
}

///
/// WasmStoreGcStateStore
///

pub struct WasmStoreGcStateStore;

impl WasmStoreGcStateStore {
    // Return the current local wasm-store GC state record.
    #[must_use]
    pub fn get() -> WasmStoreGcStateRecord {
        WASM_STORE_GC_STATE.with_borrow(|cell| cell.get().clone())
    }

    // Replace the current local wasm-store GC state record.
    pub fn set(record: WasmStoreGcStateRecord) {
        WASM_STORE_GC_STATE.with_borrow_mut(|cell| {
            cell.set(record);
        });
    }

    #[cfg(test)]
    pub fn export() -> WasmStoreGcStateData {
        WasmStoreGcStateData {
            record: Self::get(),
        }
    }

    #[cfg(test)]
    pub fn import(data: WasmStoreGcStateData) {
        Self::set(data.record);
    }

    #[cfg(test)]
    pub fn clear_for_test() {
        Self::set(WasmStoreGcStateRecord::default());
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn gc_state_round_trips_through_canonical_data_snapshot() {
        WasmStoreGcStateStore::clear_for_test();
        WasmStoreGcStateStore::set(WasmStoreGcStateRecord {
            mode: WasmStoreGcMode::Complete,
            changed_at: 11,
            prepared_at: Some(12),
            started_at: Some(13),
            completed_at: Some(14),
            runs_completed: 15,
        });

        let data = WasmStoreGcStateStore::export();
        WasmStoreGcStateStore::clear_for_test();
        WasmStoreGcStateStore::import(data.clone());

        assert_eq!(WasmStoreGcStateStore::export(), data);
        WasmStoreGcStateStore::clear_for_test();
    }
}