component-init-wasmtime 0.1.0

Tool for pre-initializing WebAssembly components: Wasmtime integration
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

use anyhow::{Context, Result, anyhow};

#[tokio::test]
async fn init_memory() -> Result<()> {
    // This component exports a `component-init` which initializes a core memory,
    // and a `run` which traps unless initialization has occured.
    let wat_component = r#"
        (component
            (core module $m
                (memory (export "memory") 1)
                ;; assert mem location 0 is 0, set it to 1
                (func (export "component-init")
                    (i32.load (i32.const 0))
                    if (unreachable) else end
                    (i32.store (i32.const 0) (i32.const 1))
                )
                ;; assert mem location 0 is 1
                (func (export "run")
                    (i32.eq (i32.const 0) (i32.load (i32.const 0)))
                    if (unreachable) else end
                )
            )
            (core instance $i (instantiate $m))
            (func (export "component-init")
                (canon lift (core func $i "component-init")))
            (func (export "run")
                (canon lift (core func $i "run")))

            ;; component_init needs the memory aliased in the component at index 0
            (alias core export $i "memory" (core memory (;0;)))
        )
    "#;
    test(wat_component).await
}

#[tokio::test]
async fn init_global() -> Result<()> {
    // This component exports a `component-init` which initializes a global,
    // and a `run` which traps unless initialization has occured.
    let wat_component = r#"
        (component
            (core module $m
                (global $g (mut i32) (i32.const 0))
                ;; assert $g is 0, set it to 1
                (func (export "component-init")
                    (global.get $g)
                    if (unreachable) else end
                    (global.set $g (i32.const 1))
                )
                ;; assert $g is 1
                (func (export "run")
                    (i32.eq (i32.const 0) (global.get $g))
                    if (unreachable) else end
                )
            )
            (core instance $i (instantiate $m))
            (func (export "component-init")
                (canon lift (core func $i "component-init")))
            (func (export "run")
                (canon lift (core func $i "run")))
        )
    "#;
    test(wat_component).await
}

async fn test(wat_component: &str) -> Result<()> {
    // component-init only supports component binaries, not wat form
    let component = wat::parse_str(wat_component)?;

    // Without initialization, run will trap.
    let err = execute(&component, "run")
        .await
        .err()
        .context("uninitialized run should trap")?;
    assert!(
        format!("{err:?}").contains("unreachable"),
        "should die with an unreachable trap, got: {err:?}"
    );

    // Initialize the component. This will execute component-init on the base component.
    let initialized_component = component_init_wasmtime::initialize(&component).await?;

    // After initialization, run will not trap.
    execute(&initialized_component, "run")
        .await
        .context("initialized component should not trap in `run`")?;

    // After initialization, component-init will trap.
    let err = execute(&initialized_component, "component-init")
        .await
        .err()
        .context("calling component-init again should trap")?;
    assert!(
        format!("{err:?}").contains("unreachable"),
        "should die with an unreachable trap, got: {err:?}"
    );

    Ok(())
}

async fn execute(component: &[u8], name: &str) -> Result<()> {
    use wasmtime::{
        Config, Engine, Store,
        component::{Component, Linker},
    };

    let mut config = Config::new();
    config.async_support(true);
    let engine = Engine::new(&config).context("create engine")?;
    let component = Component::new(&engine, component).context("load component")?;
    let mut linker = Linker::new(&engine);
    linker
        .define_unknown_imports_as_traps(&component)
        .context("unknown imports as traps")?;
    let mut store = Store::new(&engine, ());

    let instance = linker
        .instantiate_async(&mut store, &component)
        .await
        .context("instantiate")?;

    let export = instance
        .get_export_index(&mut store, None, name)
        .ok_or_else(|| anyhow!("{name} is not exported"))?;
    let func = instance
        .get_func(&mut store, export)
        .ok_or_else(|| anyhow!("{name} export is not a func"))?;
    let func = func
        .typed::<(), ()>(&mut store)
        .with_context(|| format!("type of {name} func"))?;
    func.call_async(&mut store, ())
        .await
        .with_context(|| format!("executing {name}"))?;
    func.post_return_async(&mut store)
        .await
        .with_context(|| format!("post-return {name}"))?;
    Ok(())
}