Struct SimpleSandbox

pub struct SimpleSandbox;

One-liner execution functions for maximum ease of use

Implementations

impl SimpleSandbox

pub async fn run<T, P>( source_path: P, function_name: &str, args: &[Value], ) -> Result<T>

where T: DeserializeOwned + 'static, P: AsRef<Path>,

Execute a single function with minimal setup - the simplest possible API

Examples

use wasm_sandbox::simple;
 
#[tokio::main]
async fn main() -> Result<(), wasm_sandbox::SandboxError> {
    // Execute a function from a Rust source file
    let result: i32 = simple::run("./calculator.rs", "add", &[serde_json::Value::from(5), serde_json::Value::from(3)]).await?;
     
    // Execute from pre-compiled WASM
    let result: String = simple::run("./module.wasm", "process", &[serde_json::Value::from("hello")]).await?;
    Ok(())
}

pub async fn run_with_config<T, P>( source_path: P, function_name: &str, args: &[Value], config: InstanceConfig, ) -> Result<T>

where T: DeserializeOwned + 'static, P: AsRef<Path>,

Execute with custom configuration but still simple

Examples

use wasm_sandbox::{simple, InstanceConfig, MemoryUnit};
 
#[tokio::main]
async fn main() -> Result<(), wasm_sandbox::SandboxError> {
    let config = InstanceConfig::builder()
        .memory_limit(128.mb())
        .timeout(60)
        .filesystem_read(&["/data"])
        .build()?;
     
    let result: Vec<String> = simple::run_with_config(
        "./data_processor.rs", 
        "process_files", 
        &["/data/input.txt".into()],
        config
    ).await?;
    Ok(())
}

pub async fn run_sequence<P>( source_path: P, function_calls: &[(&str, Vec<Value>)], ) -> Result<Vec<Value>>

where P: AsRef<Path>,

Execute multiple functions in sequence with the same instance

Examples

use wasm_sandbox::simple;
use serde_json::json;
 
#[tokio::main]
async fn main() -> Result<(), wasm_sandbox::SandboxError> {
    let calls = vec![
        ("initialize", vec![json!("config.json")]),
        ("process", vec![json!("data1.txt")]),
        ("process", vec![json!("data2.txt")]),
        ("finalize", vec![]),
    ];
     
    let results = simple::run_sequence("./processor.rs", &calls).await?;
    Ok(())
}

pub async fn run_sequence_with_config<P>( source_path: P, function_calls: Vec<(String, Vec<Value>)>, config: InstanceConfig, ) -> Result<Vec<Value>>

where P: AsRef<Path>,

Execute multiple functions with custom configuration

pub async fn create_reusable<P>(source_path: P) -> Result<ReusableSandbox>

where P: AsRef<Path>,

Create a reusable sandbox instance for multiple operations

Examples

use wasm_sandbox::simple;
 
#[tokio::main]
async fn main() -> Result<(), wasm_sandbox::SandboxError> {
    // Create a reusable sandbox
    let mut sandbox = simple::create_reusable("./calculator.rs").await?;
     
    // Use it multiple times
    let result1: i32 = sandbox.call("add".to_string(), vec![serde_json::Value::from(5), serde_json::Value::from(3)]).await?;
    let result2: i32 = sandbox.call("multiply".to_string(), vec![serde_json::Value::from(4), serde_json::Value::from(6)]).await?;
    Ok(())
}

pub async fn create_reusable_with_config<P>( source_path: P, config: InstanceConfig, ) -> Result<ReusableSandbox>

where P: AsRef<Path>,

Create a reusable sandbox with custom configuration