wasm-embedded-rt 0.4.0

Runtime for embedded-wasm applications
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154


use structopt::StructOpt;
use strum::VariantNames;
use strum_macros::{Display, EnumString, EnumVariantNames};
use log::{LevelFilter, debug};

#[cfg(feature="hal-mock")]
use wasm_embedded_rt::mock::MockCtx;

#[cfg(feature="hal-linux")]
use wasm_embedded_rt::linux::LinuxCtx;

#[cfg(feature="rt-wasm3")]
use wasm_embedded_rt_wasm3::{Wasm3Runtime};

#[cfg(feature="rt-wasmtime")]
use wasm_embedded_rt_wasmtime::{WasmtimeRuntime};


#[derive(Clone, PartialEq, Debug, StructOpt)]
struct Options {
    /// Backing engine
    #[structopt(long, default_value, possible_values=&Engine::VARIANTS)]
    engine: Engine,

    /// WASM Runtime
    #[structopt(long, default_value, possible_values=&Runtime::VARIANTS)]
    runtime: Runtime,

    /// Optional configuration file
    #[structopt(long)]
    config: Option<String>,

    /// WASM binary to execute
    #[structopt()]
    bin: String,

    #[structopt(long = "log-level", default_value = "info")]
    /// Configure app logging levels (warn, info, debug, trace)
    pub log_level: LevelFilter,
}

/// Runtime engine
#[derive(Clone, PartialEq, Debug, StructOpt)]
#[derive(Display, EnumVariantNames, EnumString)]
#[strum(serialize_all = "snake_case")]
#[non_exhaustive]
pub enum Engine {
    /// Mock provides mocked driver testing
    Mock,
    /// Linux provides linux-embedded-hal backed drivers
    Linux,
}

impl Default for Engine {
    fn default() -> Self {
        #[cfg(feature="hal-linux")]
        return Engine::Linux;

        #[cfg(not(feature="hal-linux"))]
        return Engine::Mock;
    }
}

#[derive(Clone, PartialEq, Debug, StructOpt)]
#[derive(Display, EnumVariantNames, EnumString)]
#[strum(serialize_all = "snake_case")]
#[non_exhaustive]
pub enum Runtime {
    /// Wasmtime based runtime
    Wasmtime,
    /// Wasm3 based runtime
    Wasm3,
}

impl Default for Runtime {
    fn default() -> Self {
        #[cfg(feature="rt-wasmtime")]
        return Runtime::Wasmtime;

        #[cfg(not(feature="rt-wasmtime"))]
        return Runtime::Wasm3;
    }
}


fn main() -> Result<(), anyhow::Error> {
    // Load options
    let opts = Options::from_args();

    // Setup logging
    let log_config = simplelog::ConfigBuilder::new()
        .add_filter_ignore_str("cranelift_codegen")
        .add_filter_ignore_str("regalloc")
        .add_filter_ignore_str("cranelift_wasm")
        .build();
    let _ = simplelog::SimpleLogger::init(opts.log_level, log_config);

    // Load WASM binary
    debug!("Loading WASM binary: {}", opts.bin);
    let bin = std::fs::read(opts.bin)?;

    #[allow(unreachable_patterns)]
    match (&opts.runtime, &opts.engine) {
        #[cfg(all(feature="rt-wasmtime", feature="hal-mock"))]
        (Runtime::Wasmtime, Engine::Mock) => {
            // Load mock configuration
            let cfg = match &opts.config {
                Some(c) => c,
                None => return Err(anyhow::anyhow!("mock mode requires --config file")),
            };
            let ctx = MockCtx::load(&cfg)?;
            let mut rt = WasmtimeRuntime::new(ctx, &bin)?;

            rt.run()?;
        },
        #[cfg(all(feature="rt-wasmtime", feature="hal-linux"))]
        (Runtime::Wasmtime, Engine::Linux) => {
            // Load linux configuration
            // TODO: config files?
            let ctx = LinuxCtx::new();
            let mut rt = WasmtimeRuntime::new(ctx, &bin)?;

            rt.run()?;
        },
        #[cfg(all(feature="rt-wasm3", feature="hal-mock"))]
        (Runtime::Wasm3, Engine::Mock) => {
            // Load mock configuration
            let cfg = match &opts.config {
                Some(c) => c,
                None => return Err(anyhow::anyhow!("mock mode requires --config file")),
            };
            let mut ctx = MockCtx::load(&cfg)?;
            let mut rt = Wasm3Runtime::new(&mut ctx, &bin)?;
            
            // TODO: bind drivers

            rt.run()?;
        },
        #[cfg(all(feature="rt-wasm3", feature="hal-linux"))]
        (Runtime::Wasm3, Engine::Linux) => {
            // Load linux configuration
            // TODO: config files?
            let mut ctx = LinuxCtx::new();
            let mut rt = Wasm3Runtime::new(&mut ctx, &bin)?;
            rt.run()?;
        },
        _ => {
            return Err(anyhow::anyhow!("Runtime was not built with {}:{} enabled", opts.runtime, opts.engine))
        },
    }

    Ok(())
}