Struct Command

Source

pub struct Command { /* private fields */ }

Expand description

Asynchronous 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(true). For the synchronous version see bindings::sync::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.

§Examples

use wasmtime::{Engine, Result, Store, Config};
use wasmtime::component::{ResourceTable, Linker, Component};
use wasmtime_wasi::{WasiCtx, WasiView, WasiCtxBuilder};
use wasmtime_wasi::bindings::Command;

// This example is an example shim of executing a component based on the
// command line arguments provided to this program.
#[tokio::main]
async fn main() -> Result<()> {
    let args = std::env::args().skip(1).collect::<Vec<_>>();

    // Configure and create `Engine`
    let mut config = Config::new();
    config.async_support(true);
    let engine = Engine::new(&config)?;

    // 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])?;


    // 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 = Command::instantiate_async(&mut store, &component, &linker).await?;
    let program_result = command.wasi_cli_run().call_run(&mut store).await?;
    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 }
}

Auto-generated bindings for an instance a component which implements the world command.

This structure can be created through a number of means depending on your requirements and what you have on hand:

The most convenient way is to use Command::instantiate_async which only needs a Store, Component, and Linker.
Alternatively you can create a CommandPre ahead of time with a Component to front-load string lookups of exports once instead of per-instantiation. This method then uses CommandPre::instantiate_async to create a Command.
If you’ve instantiated the instance yourself already then you can use Command::new.
You can also access the guts of instantiation through CommandIndices::new_instance followed by CommandIndices::load to crate an instance of this type.