tairitsu 0.5.6

Core WASM Component Model runtime — Container, Registry, WIT binding, RON/Binary interop
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

//! Image - Represents a compiled WASM component (like a Docker image)

use anyhow::{Context as AnyhowContext, Result};
use bytes::Bytes;
use wasmtime::component::Component;
use wasmtime::error::Context;
use wasmtime::{Config, Engine};
use wit_component::ComponentEncoder;

// Include the WASI adapter binary at compile time
static WASI_ADAPTER: &[u8] = include_bytes!("../res/wasi_snapshot_preview1.reactor.wasm");

/// An Image represents a compiled WASM component that can be instantiated
/// into one or more Containers. Similar to Docker images, an Image is immutable
/// and can be used to create multiple Container instances.
#[derive(Clone)]
pub struct Image {
    engine: Engine,
    component: Component,
}

impl Image {
    /// Create a new Image from WASM binary
    ///
    /// # Arguments
    /// * `wasm_binary` - The compiled WASM binary (core module format)
    ///
    /// # Returns
    /// A new Image that can be used to create Containers
    pub fn new(wasm_binary: Bytes) -> Result<Self> {
        let mut config = Config::new();
        config.wasm_component_model(true);

        let engine = Engine::new(&config).context("Failed to create WASM engine")?;

        // Convert core WASM module to component with WASI adapter
        let component_binary = ComponentEncoder::default()
            .module(wasm_binary.as_ref())
            .context("Failed to parse WASM module")?
            .validate(true)
            .adapter("wasi_snapshot_preview1", WASI_ADAPTER)
            .context("Failed to add WASI adapter")?
            .encode()
            .context("Failed to encode WASM component")?;

        let component = Component::from_binary(&engine, &component_binary)
            .context("Failed to compile WASM component")?;

        Ok(Self { engine, component })
    }

    /// Create a new Image from a WIT component binary
    ///
    /// # Arguments
    /// * `component_binary` - A pre-compiled WIT component binary
    pub fn from_component(component_binary: Bytes) -> Result<Self> {
        let mut config = Config::new();
        config.wasm_component_model(true);

        let engine = Engine::new(&config).context("Failed to create WASM engine")?;

        let component = Component::from_binary(&engine, component_binary.as_ref())
            .context("Failed to compile WASM component")?;

        Ok(Self { engine, component })
    }

    /// Get the engine used by this image
    pub(crate) fn engine(&self) -> &Engine {
        &self.engine
    }

    /// Get the component
    pub(crate) fn component(&self) -> &Component {
        &self.component
    }
}

impl std::fmt::Debug for Image {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Image").finish()
    }
}