ic-memory 0.14.3

Durable stable-memory allocation governance 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
66
67
68
69
70
71
72
73
74
75
76
77
78
79

use ic_memory::RuntimeMemory;
use ic_stable_structures::DefaultMemoryImpl;
use std::{
    cell::RefCell,
    sync::atomic::{AtomicBool, Ordering},
};

struct MacroStore;

static EAGER_INIT_RAN: AtomicBool = AtomicBool::new(false);
const MACRO_AUTHORITY: &str = "runtime_macros";

ic_memory::ic_memory_range!(authority = MACRO_AUTHORITY, start = 130, end = 139);

ic_memory::ic_memory_range!(
    authority = MACRO_AUTHORITY,
    start = 140,
    end = 149,
    mode = Allowed
);
ic_memory::ic_memory_declaration!(authority = MACRO_AUTHORITY, key = "macro.logical.rows.v1");

ic_memory::eager_init!({
    EAGER_INIT_RAN.store(true, Ordering::SeqCst);
});

thread_local! {
    static MACRO_MEMORY: RefCell<Option<RuntimeMemory<DefaultMemoryImpl>>> = {
        assert!(
            ic_memory::is_default_memory_manager_bootstrapped()
                .expect("default runtime lifecycle")
        );
        RefCell::new(Some(ic_memory::ic_memory_key!(
            authority = MACRO_AUTHORITY,
            key = "macro.integration.users.v1",
            ty = MacroStore,
            id = 130,
        )
        .expect("committed macro memory")))
    };
}

fn bootstrap_and_require_thread_local_ledger() {
    let validated = ic_memory::bootstrap_default_memory_manager().expect("bootstrap");
    ic_memory::default_memory_manager_diagnostic_export()
        .expect("bootstrapped runtime should expose its local ledger");

    assert!(EAGER_INIT_RAN.load(Ordering::SeqCst));
    assert!(
        validated
            .declarations()
            .iter()
            .any(|declaration| declaration.stable_key().as_str() == "macro.integration.users.v1")
    );
    let logical = ic_memory::open_default_memory_manager_memory_by_key("macro.logical.rows.v1")
        .expect("key-only host adoption");
    assert_eq!(ic_stable_structures::Memory::size(&logical), 0);
    assert_eq!(
        validated
            .slot_for(&ic_memory::StableKey::parse("macro.logical.rows.v1").unwrap())
            .unwrap()
            .memory_manager_id()
            .unwrap(),
        140
    );
    MACRO_MEMORY.with(|memory| assert!(memory.borrow().is_some()));
    ic_memory::open_default_memory_manager_memory("macro.integration.users.v1", 130)
        .expect("open macro memory");
}

#[test]
fn first_libtest_default_runtime_bootstraps_its_own_memory() {
    bootstrap_and_require_thread_local_ledger();
}

#[test]
fn second_libtest_default_runtime_bootstraps_its_own_memory() {
    bootstrap_and_require_thread_local_ledger();
}