Struct WasmSandbox

pub struct WasmSandbox { /* private fields */ }

Main sandbox controller

Implementations

impl WasmSandbox

pub fn new() -> Result<Self>

Create a new sandbox with default configuration

pub fn with_config(config: SandboxConfig) -> Result<Self>

Create a sandbox with custom configuration

pub fn load_module(&self, wasm_bytes: &[u8]) -> Result<ModuleId>

Load a WASM module

pub fn create_instance( &mut self, module_id: ModuleId, instance_config: Option<InstanceConfig>, ) -> Result<InstanceId>

Create a new instance of a module

pub async fn call_function<P, R>( &self, instance_id: InstanceId, function_name: &str, params: P, ) -> Result<R>

where P: Serialize + 'static, R: for<'de> Deserialize<'de> + 'static,

Run a function in the sandbox

pub async fn from_source(source_path: &str) -> Result<Self>

Create a new sandbox from source code with automatic compilation and configuration.

This is the easiest way to get started - just point to a source file and the sandbox will automatically detect the language, compile it to WebAssembly, and set up safe defaults.

Examples

use wasm_sandbox::WasmSandbox;
 
#[tokio::main]
async fn main() -> Result<(), wasm_sandbox::Error> {
    // Rust source file
    let sandbox = WasmSandbox::from_source("./calculator.rs").await?;
    let result: i32 = sandbox.call("add", &(5, 3)).await?;
     
    // Python source (when supported)
    let sandbox = WasmSandbox::from_source("./processor.py").await?;
    Ok(())
}

pub fn builder() -> WasmSandboxBuilder

Create a new sandbox builder for more control over configuration.

Examples

use wasm_sandbox::WasmSandbox;
use std::time::Duration;
 
#[tokio::main]
async fn main() -> Result<(), wasm_sandbox::Error> {
    let sandbox = WasmSandbox::builder()
        .source("./my_program.rs")
        .timeout_duration(Duration::from_secs(30))
        .memory_limit(64 * 1024 * 1024) // 64MB
        .enable_file_access(false)
        .build()
        .await?;
    Ok(())
}

pub async fn call<P, R>(&self, function_name: &str, params: &P) -> Result<R>

where P: Serialize + Send + Sync, R: for<'de> Deserialize<'de> + Send + Sync + 'static,

Call a function in the sandbox with automatic instance management.

This method automatically creates an instance if needed and calls the function. For more control, use the explicit instance creation methods.

pub async fn execute_main(&self, args: &[&str]) -> Result<String>

Execute a complete program with command-line arguments.

This calls the main function of the WebAssembly module with the provided arguments.

pub fn runtime(&self) -> &dyn WasmRuntime

Get a reference to the runtime

pub fn runtime_mut(&mut self) -> &mut dyn WasmRuntime

Get a mutable reference to the runtime

pub fn get_instance(&self, instance_id: InstanceId) -> Option<&SandboxInstance>

Get a reference to an instance

pub fn get_instance_mut( &mut self, instance_id: InstanceId, ) -> Option<&mut SandboxInstance>

Get a mutable reference to an instance

pub fn remove_instance( &mut self, instance_id: InstanceId, ) -> Option<SandboxInstance>

Remove an instance

pub fn instance_ids(&self) -> Vec<InstanceId>

Get all instance IDs

pub fn get_instance_resource_usage( &self, instance_id: InstanceId, ) -> Result<DetailedResourceUsage>

Get resource usage for a specific instance

pub fn reset_instance(&mut self, instance_id: InstanceId) -> Result<()>

Reset an instance (recreate it with the same configuration)