Struct wasmtime_wasi::bindings::CommandPre

pub struct CommandPre<T> { /* private fields */ }

Pre-instantiated analog of Command

This can be used to front-load work such as export lookup before instantiation.

Examples

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

// 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])?;
    let pre = CommandPre::new(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 = pre.instantiate_async(&mut store).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 a pre-instantiated version of a component which implements the world command.

This structure is created through CommandPre::new which takes a InstancePre that has been created through a Linker.

For more information see Command as well.

Implementations

impl<_T> CommandPre<_T>

pub fn new(instance_pre: InstancePre<_T>) -> Result<Self>

Creates a new copy of CommandPre bindings which can then be used to instantiate into a particular store.

This method may fail if the component behind instance_pre does not have the required exports.

pub fn engine(&self) -> &Engine

pub fn instance_pre(&self) -> &InstancePre<_T>

pub async fn instantiate_async( &self, store: impl AsContextMut<Data = _T>, ) -> Result<Command>

where _T: Send,

Instantiates a new instance of Command within the store provided.

This function will use self as the pre-instantiated instance to perform instantiation. Afterwards the preloaded indices in self are used to lookup all exports on the resulting instance.

Trait Implementations

impl<T> Clone for CommandPre<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.