Struct wasmer_wasix::WasiEnv

pub struct WasiEnv {

    pub control_plane: WasiControlPlane,
    pub process: WasiProcess,
    pub thread: WasiThread,
    pub layout: WasiMemoryLayout,
    pub vfork: Option<WasiVFork>,
    pub poll_seed: u64,
    pub bin_factory: BinFactory,
    pub owned_handles: Vec<WasiThreadHandle>,
    pub runtime: Arc<dyn Runtime + Send + Sync + 'static>,
    pub capabilities: Capabilities,
    pub enable_deep_sleep: bool,
    pub enable_journal: bool,
    pub enable_exponential_cpu_backoff: Option<Duration>,
    pub replaying_journal: bool,
    /* private fields */
}

The environment provided to the WASI imports.

Fields

control_plane: WasiControlPlane

process: WasiProcess

Represents the process this environment is attached to

thread: WasiThread

Represents the thread this environment is attached to

layout: WasiMemoryLayout

Represents the layout of the memory

vfork: Option<WasiVFork>

Represents a fork of the process that is currently in play

poll_seed: u64

Seed used to rotate around the events returned by poll_oneoff

bin_factory: BinFactory

Binary factory attached to this environment

owned_handles: Vec<WasiThreadHandle>

List of the handles that are owned by this context (this can be used to ensure that threads own themselves or others)

runtime: Arc<dyn Runtime + Send + Sync + 'static>

Implementation of the WASI runtime.

capabilities: Capabilities

enable_deep_sleep: bool

Is this environment capable and setup for deep sleeping

enable_journal: bool

Enables the snap shotting functionality

enable_exponential_cpu_backoff: Option<Duration>

Enables an exponential backoff of the process CPU usage when there are no active run tokens (when set holds the maximum amount of time that it will pause the CPU)

replaying_journal: bool

Flag that indicatees if the environment is currently replaying the journal (and hence it should not record new events)

Implementations

impl WasiEnv

pub fn builder(program_name: impl Into<String>) -> WasiEnvBuilder

Construct a new WasiEnvBuilder that allows customizing an environment.

pub fn fork(&self) -> Result<(Self, WasiThreadHandle), ControlPlaneError>

Forking the WasiState is used when either fork or vfork is called

pub fn pid(&self) -> WasiProcessId

pub fn tid(&self) -> WasiThreadId

pub fn will_use_asyncify(&self) -> bool

Returns true if this WASM process will need and try to use asyncify while its running which normally means.

pub fn reinit(&mut self) -> Result<(), WasiStateCreationError>

Re-initializes this environment so that it can be executed again

pub unsafe fn capable_of_deep_sleep(&self) -> bool

Returns true if this module is capable of deep sleep (needs asyncify to unwind and rewin)

Safety

This function should only be called from within a syscall as it accessed objects that are a thread local (functions)

pub fn layout(&self) -> &WasiMemoryLayout

Returns true if this thread can go into a deep sleep

pub fn runtime(&self) -> &(dyn Runtime + Send + Sync)

Returns a copy of the current runtime implementation for this environment

pub fn tasks(&self) -> &Arc<dyn VirtualTaskManager>

Returns a copy of the current tasks implementation for this environment

pub fn fs_root(&self) -> &WasiFsRoot

pub fn set_runtime<R>(&mut self, runtime: R)

where R: Runtime + Send + Sync + 'static,

Overrides the runtime implementation for this environment

pub fn active_threads(&self) -> u32

Returns the number of active threads

pub fn process_signals_and_exit( ctx: &mut FunctionEnvMut<'_, Self>, ) -> WasiResult<bool>

Porcesses any signals that are batched up or any forced exit codes

pub fn should_exit(&self) -> Option<ExitCode>

Returns an exit code if the thread or process has been forced to exit

pub fn net(&self) -> &DynVirtualNetworking

Accesses the virtual networking implementation

pub fn try_clone_instance(&self) -> Option<Instance>

Tries to clone the instance from this environment

pub fn stdout( &self, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Get the VirtualFile object at stdout

pub fn stderr( &self, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Get the VirtualFile object at stderr

pub fn stdin( &self, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Get the VirtualFile object at stdin

pub fn should_journal(&self) -> bool

Returns true if the process should perform snapshots or not

pub fn active_journal(&self) -> Result<&DynJournal, Errno>

Available on crate feature journal only.

Returns the active journal or fails with an error

pub fn has_snapshot_trigger(&self, trigger: SnapshotTrigger) -> bool

Available on crate feature journal only.

Returns true if a particular snapshot trigger is enabled

pub fn pop_snapshot_trigger(&mut self, trigger: SnapshotTrigger) -> bool

Available on crate feature journal only.

Returns true if a particular snapshot trigger is enabled

pub fn std_dev_get( &self, fd: Fd, ) -> Result<Option<Box<dyn VirtualFile + Send + Sync + 'static>>, FsError>

Internal helper function to get a standard device handle. Expects one of __WASI_STDIN_FILENO, __WASI_STDOUT_FILENO, __WASI_STDERR_FILENO.

pub fn use_package( &self, pkg: &BinaryPackage, ) -> Result<(), WasiStateCreationError>

Make all the commands in a BinaryPackage available to the WASI instance.

The BinaryPackageCommand::atom() will be saved to /bin/command.

This will also merge the command’s filesystem (BinaryPackage::webc_fs) into the current filesystem.

pub fn uses<I>(&self, uses: I) -> Result<(), WasiStateCreationError>

where I: IntoIterator<Item = String>,

Given a list of packages, load them from the registry and make them available.

pub fn map_commands( &self, map_commands: HashMap<String, PathBuf>, ) -> Result<(), WasiStateCreationError>

Available on crate feature sys only.

pub fn blocking_on_exit(&self, exit_code: Option<ExitCode>)

Cleans up all the open files (if this is the main thread)

pub fn on_exit(&self, exit_code: Option<ExitCode>) -> BoxFuture<'static, ()>

Cleans up all the open files (if this is the main thread)

Trait Implementations

impl Clone for WasiEnv

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WasiEnv

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

Formats the value using the given formatter.