Struct 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.

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.
    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 }
}

---

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 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 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.

These methods are all equivalent to one another and move around the tradeoff of what work is performed when.

Implementations

impl Command

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

Convenience wrapper around CommandPre::new and CommandPre::instantiate.

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

Convenience wrapper around CommandIndices::new_instance and CommandIndices::load.

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

where T: Send, U: Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host + Host,

pub fn wasi_cli_run(&self) -> &Guest