Struct wasmtime_wasi::bindings::sync::CommandPre

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

Pre-instantiated analogue of Command.

This works the same as Command but enables front-loading work such as export lookup to 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::sync::CommandPre;

// 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 = 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(&mut store)?;
    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 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 fn instantiate( &self, store: impl AsContextMut<Data = _T>, ) -> Result<Command>

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.