Struct wasmer_wasi::PluggableRuntimeImplementation

pub struct PluggableRuntimeImplementation {
    pub bus: Box<dyn VirtualBus + Sync>,
    pub networking: Box<dyn VirtualNetworking + Sync>,
    pub thread_id_seed: AtomicU32,
}

Fields

bus: Box<dyn VirtualBus + Sync>

networking: Box<dyn VirtualNetworking + Sync>

thread_id_seed: AtomicU32

Implementations

impl PluggableRuntimeImplementation

pub fn set_bus_implementation<I>(&mut self, bus: I)where
    I: VirtualBus + Sync,

pub fn set_networking_implementation<I>(&mut self, net: I)where
    I: VirtualNetworking + Sync,

Trait Implementations

impl Debug for PluggableRuntimeImplementation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PluggableRuntimeImplementation

fn default() -> Self

Returns the “default value” for a type.

impl WasiRuntimeImplementation for PluggableRuntimeImplementation

fn bus(&self) -> &dyn VirtualBus

For WASI runtimes that support it they can implement a message BUS implementation which allows runtimes to pass serialized messages between each other similar to RPC’s. BUS implementation can be implemented that communicate across runtimes thus creating a distributed computing architecture.

fn networking(&self) -> &dyn VirtualNetworking

Provides access to all the networking related functions such as sockets. By default networking is not implemented.

fn thread_generate_id(&self) -> WasiThreadId

Generates a new thread ID

fn tty_get(&self) -> WasiTtyState

Gets the TTY state

fn tty_set(&self, _tty_state: WasiTtyState)

Sets the TTY state

fn thread_spawn(
    &self,
    _callback: Box<dyn FnOnce() + Send + 'static>
) -> Result<(), WasiThreadError>

Spawns a new thread by invoking the

fn thread_parallelism(&self) -> Result<usize, WasiThreadError>

Returns the amount of parallelism that is possible on this platform

fn yield_now(&self, _id: WasiThreadId) -> Result<(), WasiError>

Invokes whenever a WASM thread goes idle. In some runtimes (like singlethreaded execution environments) they will need to do asynchronous work whenever the main thread goes idle and this is the place to hook for that.

fn getpid(&self) -> Option<u32>

Gets the current process ID