Struct PluggableRuntime 

pub struct PluggableRuntime {
    pub rt: Arc<dyn VirtualTaskManager>,
    pub networking: DynVirtualNetworking,
    pub http_client: Option<DynHttpClient>,
    pub package_loader: Arc<dyn PackageLoader + Send + Sync>,
    pub source: Arc<dyn Source + Send + Sync>,
    pub engine: Engine,
    pub module_cache: Arc<dyn ModuleCache + Send + Sync>,
    pub tty: Option<Arc<dyn TtyBridge + Send + Sync>>,
    pub read_only_journals: Vec<Arc<DynReadableJournal>>,
    pub writable_journals: Vec<Arc<DynJournal>>,
    pub instantiation_hooks: Vec<Arc<dyn InstantiationHook>>,
}

Fields

rt: Arc<dyn VirtualTaskManager>

networking: DynVirtualNetworking

http_client: Option<DynHttpClient>

package_loader: Arc<dyn PackageLoader + Send + Sync>

source: Arc<dyn Source + Send + Sync>

engine: Engine

module_cache: Arc<dyn ModuleCache + Send + Sync>

tty: Option<Arc<dyn TtyBridge + Send + Sync>>

read_only_journals: Vec<Arc<DynReadableJournal>>

writable_journals: Vec<Arc<DynJournal>>

instantiation_hooks: Vec<Arc<dyn InstantiationHook>>

Implementations

impl PluggableRuntime

pub fn new(rt: Arc<dyn VirtualTaskManager>) -> Self

pub fn set_networking_implementation<I>(&mut self, net: I) -> &mut Self

where I: VirtualNetworking + Sync,

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

pub fn set_tty(&mut self, tty: Arc<dyn TtyBridge + Send + Sync>) -> &mut Self

pub fn set_module_cache( &mut self, module_cache: impl ModuleCache + Send + Sync + 'static, ) -> &mut Self

pub fn set_source(&mut self, source: impl Source + Send + 'static) -> &mut Self

pub fn set_package_loader( &mut self, package_loader: impl PackageLoader + 'static, ) -> &mut Self

pub fn set_http_client( &mut self, client: impl HttpClient + Send + Sync + 'static, ) -> &mut Self

pub fn add_read_only_journal( &mut self, journal: Arc<DynReadableJournal>, ) -> &mut Self

pub fn add_writable_journal(&mut self, journal: Arc<DynJournal>) -> &mut Self

pub fn with_additional_imports( &mut self, imports: impl Fn(&Module, &mut StoreMut<'_>) -> Result<Imports> + Send + Sync + 'static, ) -> &mut Self

Registers a hook that only creates additional imports.

pub fn with_instance_setup( &mut self, callback: impl Fn(&Module, &mut StoreMut<'_>, &Instance, Option<&Memory>) -> Result<()> + Send + Sync + 'static, ) -> &mut Self

Registers a hook that only configures newly created instances.

pub fn with_instantiation_hook( &mut self, hook: impl InstantiationHook, ) -> &mut Self

Registers a hook that takes part in both phases of instantiation, so it can carry InstantiationState from its imports to its instance setup.

Trait Implementations

impl Clone for PluggableRuntime

fn clone(&self) -> PluggableRuntime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PluggableRuntime

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

Formats the value using the given formatter.

impl Runtime for PluggableRuntime

fn networking(&self) -> &DynVirtualNetworking

Provides access to all the networking related functions such as sockets.

fn http_client(&self) -> Option<&DynHttpClient>

Get a custom HTTP client

fn package_loader(&self) -> Arc<dyn PackageLoader + Send + Sync>

A package loader.

fn source(&self) -> Arc<dyn Source + Send + Sync>

The package registry.

fn engine(&self) -> Engine

Get a wasmer::Engine for module compilation.

fn new_store(&self) -> Store

Create a new wasmer::Store.

fn task_manager(&self) -> &Arc<dyn VirtualTaskManager>

Retrieve the active VirtualTaskManager.

fn tty(&self) -> Option<&(dyn TtyBridge + Send + Sync)>

Get access to the TTY used by the environment.

fn module_cache(&self) -> Arc<dyn ModuleCache + Send + Sync>

A cache for compiled modules.

fn additional_imports( &self, module: &Module, store: &mut StoreMut<'_>, ) -> Result<(Imports, InstantiationState)>

Create additional imports for a new WASIX instance in the provided store.

fn configure_new_instance( &self, module: &Module, store: &mut StoreMut<'_>, instance: &Instance, imported_memory: Option<&Memory>, state: InstantiationState, ) -> Result<()>

Configure an instantiated instance before initialization/startup.

fn read_only_journals<'a>( &'a self, ) -> Box<dyn Iterator<Item = Arc<DynReadableJournal>> + 'a>

The list of all read-only journals which will be used to restore the state of the runtime at a particular point in time

fn writable_journals<'a>( &'a self, ) -> Box<dyn Iterator<Item = Arc<DynJournal>> + 'a>

The list of writable journals which will be appended to

fn active_journal(&self) -> Option<&DynJournal>

The snapshot capturer takes and restores snapshots of the WASM process at specific points in time by reading and writing log entries

fn resolve_module<'a>( &'a self, input: ModuleInput<'a>, engine: Option<&Engine>, on_progress: Option<ModuleLoadProgressReporter>, ) -> BoxFuture<'a, Result<Module, SpawnError>>

The primary way to load a module given a module input.

fn resolve_module_sync( &self, input: ModuleInput<'_>, engine: Option<&Engine>, on_progress: Option<ModuleLoadProgressReporter>, ) -> Result<Module, SpawnError>

Sync variant of Self::resolve_module.

fn load_command_module( &self, cmd: &BinaryPackageCommand, ) -> BoxFuture<'_, Result<Module, SpawnError>>

👎Deprecated since 0.601.0: Use resolve_module instead

Load the module for a command.

fn load_command_module_sync( &self, cmd: &BinaryPackageCommand, ) -> Result<Module, SpawnError>

👎Deprecated since 0.601.0: Use resolve_module_sync instead

Sync version of Self::load_command_module.

fn load_module<'a>( &'a self, wasm: &'a [u8], ) -> BoxFuture<'a, Result<Module, SpawnError>>

👎Deprecated since 0.601.0: Use resolve_module instead

Load a WebAssembly module from raw bytes.

fn load_module_sync(&self, wasm: &[u8]) -> Result<Module, SpawnError>

👎Deprecated since 0.601.0: Use load_command_module or load_hashed_module instead - this method can have high overhead

Synchronous version of Self::load_module.

fn load_hashed_module( &self, module: HashedModuleData, engine: Option<&Engine>, ) -> BoxFuture<'_, Result<Module, SpawnError>>

Load a WebAssembly module from pre-hashed data.

fn load_hashed_module_sync( &self, wasm: HashedModuleData, engine: Option<&Engine>, ) -> Result<Module, SpawnError>

Synchronous version of Self::load_hashed_module.

fn on_taint(&self, _reason: TaintReason)

Callback thats invokes whenever the instance is tainted, tainting can occur for multiple reasons however the most common is a panic within the process