Struct wasmtime_wasi::bindings::sync::Command

pub struct Command { /* private fields */ }

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). For the asynchronous version see bindings::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.

Note: it’s recommended to use wasmtime_wasi::add_to_linker_sync instead of the auto-generated Command::add_to_linker here.

Examples

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, and then pre-instantiate it.
    let mut linker = Linker::<MyState>::new(&engine);
    wasmtime_wasi::add_to_linker_async(&mut linker)?;
    let component = Component::from_file(&engine, &args[0])?;
    let pre = linker.instantiate_pre(&component)?;


    // 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);
    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, _instance) = Command::instantiate_pre(&mut store, &pre)?;
    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 }
}

Implementations

impl Command

pub fn add_to_linker<T, U>( linker: &mut Linker<T>, get: impl Fn(&mut T) -> &mut U + Send + Sync + Copy + 'static ) -> Result<()>

where U: Host + Host + Host,

pub fn instantiate<T>( store: impl AsContextMut<Data = T>, component: &Component, linker: &Linker<T> ) -> Result<(Self, Instance)>

Instantiates the provided module using the specified parameters, wrapping up the result in a structure that translates between wasm and the host.

pub fn instantiate_pre<T>( store: impl AsContextMut<Data = T>, instance_pre: &InstancePre<T> ) -> Result<(Self, Instance)>

Instantiates a pre-instantiated module using the specified parameters, wrapping up the result in a structure that translates between wasm and the host.

pub fn new(store: impl AsContextMut, instance: &Instance) -> Result<Self>

Low-level creation wrapper for wrapping up the exports of the instance provided in this structure of wasm exports.

This function will extract exports from the instance defined within store and wrap them all up in the returned structure which can be used to interact with the wasm module.

pub fn wasi_cli_run(&self) -> &Guest