ic-memory 0.44.0

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

use ic_memory::RuntimeMemory;
use ic_stable_structures::DefaultMemoryImpl;
use std::cell::RefCell;

const MACRO_AUTHORITY: &str = "runtime_macros";

fn snapshot() -> ic_memory::SealedDeclarationSnapshot {
    ic_memory::SealedDeclarationSnapshot::new(vec![
        ic_memory::MemoryRequest::new(
            MACRO_AUTHORITY,
            "macro.logical.rows.v1",
            ic_memory::SchemaMetadata::default(),
        )
        .unwrap(),
        ic_memory::MemoryRequest::new(
            MACRO_AUTHORITY,
            "macro.integration.users.v1",
            ic_memory::SchemaMetadata::default(),
        )
        .unwrap(),
    ])
    .unwrap()
}

thread_local! {
    static MACRO_MEMORY: RefCell<Option<RuntimeMemory<DefaultMemoryImpl>>> = const { RefCell::new(None) };
}

#[test]
fn host_injects_component_memory_that_outlives_its_runtime() {
    let mut host = ic_memory::MemoryRuntime::new(DefaultMemoryImpl::default()).unwrap();
    let validated = host
        .bootstrap(&snapshot(), &pool(), &ic_memory::GenericAllocationPolicy)
        .expect("bootstrap")
        .clone();
    host.diagnostic_export()
        .expect("bootstrapped runtime should expose its local ledger");

    assert!(
        validated
            .declarations()
            .iter()
            .any(|declaration| declaration.stable_key().as_str() == "macro.integration.users.v1")
    );
    let logical = host
        .open_memory("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()
            .id(),
        11
    );
    let component_memory = host.open_memory("macro.integration.users.v1").unwrap();
    MACRO_MEMORY.with(|memory| *memory.borrow_mut() = Some(component_memory));
    drop(host);
    MACRO_MEMORY.with(|memory| {
        assert_eq!(
            ic_stable_structures::Memory::size(memory.borrow().as_ref().unwrap()),
            0,
        );
    });
}

fn pool() -> ic_memory::MemoryAllocationPool {
    ic_memory::MemoryAllocationPool::new(
        vec![ic_memory::MemoryAuthority::new("runtime_macros", "macro.").unwrap()],
        vec![],
    )
    .unwrap()
}