Struct wasmtime_provider::WasmtimeEngineProviderBuilder

pub struct WasmtimeEngineProviderBuilder<'a> { /* private fields */ }

Used to build WasmtimeEngineProvider instances.

Implementations

impl<'a> WasmtimeEngineProviderBuilder<'a>

pub fn new() -> Self

Create a builder instance

pub fn module_bytes(self, module_bytes: &'a [u8]) -> Self

Provide contents of the WebAssembly module

pub fn module(self, module: Module) -> Self

Provide a preloaded wasmtime::Module

Warning: the wasmtime::Engine used to load it must be provided via the WasmtimeEngineProviderBuilder::engine method, otherwise the code will panic at runtime later.

pub fn engine(self, engine: Engine) -> Self

Provide a preinitialized wasmtime::Engine

Warning: when used, engine specific options like cache and enable_epoch_interruptions must be pre-configured by the user. WasmtimeEngineProviderBuilder won’t be able to configure them at build time.

pub fn wasi_params(self, wasi: WasiParams) -> Self

WASI params

pub fn enable_epoch_interruptions( self, wapc_init_deadline: u64, wapc_func_deadline: u64 ) -> Self

Enable Wasmtime epoch-based interruptions and set the deadlines to be enforced

Two kind of deadlines have to be set:

• wapc_init_deadline: the number of ticks the waPC initialization code can take before the code is interrupted. This is the code usually defined inside of the wapc_init/_start functions
• wapc_func_deadline: the number of ticks any regular waPC guest function can run before its terminated by the host

Both these limits are expressed using the number of ticks that are allowed before the WebAssembly execution is interrupted. It’s up to the embedder of waPC to define how much time a single tick is granted. This could be 1 second, 10 nanoseconds, or whatever the user prefers.

Warning: when providing an instance of wasmtime::Engine via the WasmtimeEngineProvider::engine helper, ensure the wasmtime::Engine has been created with the epoch_interruption feature enabled

pub fn build_pre(&self) -> Result<WasmtimeEngineProviderPre, Error>

Create a WasmtimeEngineProviderPre instance. This instance can then be reused as many time as wanted to quickly instantiate a WasmtimeEngineProvider by using the WasmtimeEngineProviderPre::rehydrate method.

pub fn build(&self) -> Result<WasmtimeEngineProvider, Error>

Create a WasmtimeEngineProvider instance

Trait Implementations

impl<'a> Default for WasmtimeEngineProviderBuilder<'a>

fn default() -> WasmtimeEngineProviderBuilder<'a>

Returns the “default value” for a type.