hermit-wasm 0.1.1

Running WASM modules inside a lightweight virtual machine
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

mod generated {
	use crate::StreamError;

	wasmtime::component::bindgen!({
		path: "wit",
		world: "wasi:cli/command",
		trappable_imports: true,
		trappable_error_type: {
			"wasi:io/streams/stream-error" => StreamError,
			//"wasi:filesystem/types/error-code" => FsError,
			//"wasi:sockets/network/error-code" => SocketError,
		},
		//require_store_data_send: true,
	});
}

pub use self::generated::exports;
pub use self::generated::wasi::*;

/// Synchronous bindings to execute and run a `wasi:cli/command`.
///
/// This structure is automatically generated by `bindgen!` and is intended
/// to be used with [`Config::async_support(false)`][async]. For the
/// asynchronous version see [`bindings::Command`](super::Command).
///
/// This can be used for a more "typed" view of executing a command
/// component through the [`Command::wasi_cli_run`] method plus
/// [`Guest::call_run`](exports::wasi::cli::run::Guest::call_run).
///
/// [async]: wasmtime::Config::async_support
/// [`wasmtime_wasi::add_to_linker_sync`]: crate::add_to_linker_sync
///
/// # Examples
///
/// ```no_run
/// use wasmtime::{Engine, Result, Store, Config};
/// use wasmtime::component::{ResourceTable, Linker, Component};
/// use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
/// use wasmtime_wasi::bindings::sync::Command;
///
/// // This example is an example shim of executing a component based on the
/// // command line arguments provided to this program.
/// fn main() -> Result<()> {
///     let args = std::env::args().skip(1).collect::<Vec<_>>();
///
///     // Configure and create `Engine`
///     let engine = Engine::default();
///
///     // Configure a `Linker` with WASI, compile a component based on
///     // command line arguments.
///     let mut linker = Linker::<MyState>::new(&engine);
///     wasmtime_wasi::add_to_linker_async(&mut linker)?;
///     let component = Component::from_file(&engine, &args[0])?;
///
///
///     // Configure a `WasiCtx` based on this program's environment. Then
///     // build a `Store` to instantiate into.
///     let mut builder = WasiCtxBuilder::new();
///     builder.inherit_stdio().inherit_env().args(&args[2..]);
///     let mut store = Store::new(
///         &engine,
///         MyState {
///             ctx: builder.build(),
///             table: ResourceTable::new(),
///         },
///     );
///
///     // Instantiate the component and we're off to the races.
///     let command = Command::instantiate(&mut store, &component, &linker)?;
///     let program_result = command.wasi_cli_run().call_run(&mut store)?;
///     match program_result {
///         Ok(()) => Ok(()),
///         Err(()) => std::process::exit(1),
///     }
/// }
///
/// struct MyState {
///     ctx: WasiCtx,
///     table: ResourceTable,
/// }
///
/// impl WasiView for MyState {
///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
/// }
/// ```
///
/// ---
pub use self::generated::Command;