Struct IsolateSandbox 

pub struct IsolateSandbox {
    pub box_id: u32,
    pub isolate_bin: String,
    pub directory_rules: Vec<DirectoryRule>,
    pub env_rules: Vec<EnvRule>,
    pub stdin_file: Option<String>,
    pub stdout_file: Option<String>,
    pub stderr_file: Option<String>,
    pub stderr_to_stdout: bool,
    pub chdir: Option<String>,
    pub meta_file: Option<PathBuf>,
    pub special_options: SpecialOptions,
}

Main isolate sandbox implementation

Fields

box_id: u32

isolate_bin: String

directory_rules: Vec<DirectoryRule>

env_rules: Vec<EnvRule>

stdin_file: Option<String>

stdout_file: Option<String>

stderr_file: Option<String>

stderr_to_stdout: bool

chdir: Option<String>

meta_file: Option<PathBuf>

special_options: SpecialOptions

Implementations

impl IsolateSandbox

pub fn new(box_id: u32) -> Self

Examples found in repository

examples/sandbox_usage.rs (line 65)

async fn basic_example() -> Result<()> {
    println!("=== Example 1: Basic Command Execution ===");

    // Create a sandbox with box ID 0
    let sandbox = IsolateSandbox::new(0)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_0.txt"))
        .verbose();

    // Initialize the sandbox
    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Run a simple echo command
    let result = sandbox
        .run("/bin/echo", ["Hello from Isolate Sandbox!"], &limits)
        .await?;

    println!("Exit code: {:?}", result.exit_code);
    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s", result.time_used);
    println!("Memory used: {} KB", result.memory_used);

    // Cleanup the sandbox
    sandbox.cleanup().await?;
    println!("✓ Basic example completed\n");

    Ok(())
}

/// Example 2: Using environment variables
async fn environment_example() -> Result<()> {
    println!("=== Example 2: Environment Variables ===");

    let sandbox = IsolateSandbox::new(1)
        .with_env_rule(EnvRule::Set("GREETING".to_string(), "Hello".to_string()))
        .with_env_rule(EnvRule::Set("NAME".to_string(), "Isolate".to_string()))
        .with_env_rule(EnvRule::Inherit("PATH".to_string()))
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_1.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Use environment variables in a bash command
    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo \"$GREETING, $NAME!\" && echo \"Current directory: $(pwd)\"",
            ],
            &limits,
        )
        .await?;

    println!("Output:\n{}", result.stdout);
    println!("Exit code: {:?}", result.exit_code);

    sandbox.cleanup().await?;
    println!("✓ Environment example completed\n");

    Ok(())
}

/// Example 3: File sharing between host and sandbox
async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}

pub async fn init(&self, limits: &ResourceLimits) -> Result<()>

Initialize the sandbox

Examples found in repository

examples/sandbox_usage.rs (line 71)

async fn basic_example() -> Result<()> {
    println!("=== Example 1: Basic Command Execution ===");

    // Create a sandbox with box ID 0
    let sandbox = IsolateSandbox::new(0)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_0.txt"))
        .verbose();

    // Initialize the sandbox
    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Run a simple echo command
    let result = sandbox
        .run("/bin/echo", ["Hello from Isolate Sandbox!"], &limits)
        .await?;

    println!("Exit code: {:?}", result.exit_code);
    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s", result.time_used);
    println!("Memory used: {} KB", result.memory_used);

    // Cleanup the sandbox
    sandbox.cleanup().await?;
    println!("✓ Basic example completed\n");

    Ok(())
}

/// Example 2: Using environment variables
async fn environment_example() -> Result<()> {
    println!("=== Example 2: Environment Variables ===");

    let sandbox = IsolateSandbox::new(1)
        .with_env_rule(EnvRule::Set("GREETING".to_string(), "Hello".to_string()))
        .with_env_rule(EnvRule::Set("NAME".to_string(), "Isolate".to_string()))
        .with_env_rule(EnvRule::Inherit("PATH".to_string()))
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_1.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Use environment variables in a bash command
    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo \"$GREETING, $NAME!\" && echo \"Current directory: $(pwd)\"",
            ],
            &limits,
        )
        .await?;

    println!("Output:\n{}", result.stdout);
    println!("Exit code: {:?}", result.exit_code);

    sandbox.cleanup().await?;
    println!("✓ Environment example completed\n");

    Ok(())
}

/// Example 3: File sharing between host and sandbox
async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}

pub async fn run<I, S>( &self, program: &str, args: I, limits: &ResourceLimits, ) -> Result<ExecutionResult>

where I: IntoIterator<Item = S>, S: AsRef<str>,

Run a command in the sandbox

Examples found in repository

examples/sandbox_usage.rs (line 75)

async fn basic_example() -> Result<()> {
    println!("=== Example 1: Basic Command Execution ===");

    // Create a sandbox with box ID 0
    let sandbox = IsolateSandbox::new(0)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_0.txt"))
        .verbose();

    // Initialize the sandbox
    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Run a simple echo command
    let result = sandbox
        .run("/bin/echo", ["Hello from Isolate Sandbox!"], &limits)
        .await?;

    println!("Exit code: {:?}", result.exit_code);
    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s", result.time_used);
    println!("Memory used: {} KB", result.memory_used);

    // Cleanup the sandbox
    sandbox.cleanup().await?;
    println!("✓ Basic example completed\n");

    Ok(())
}

/// Example 2: Using environment variables
async fn environment_example() -> Result<()> {
    println!("=== Example 2: Environment Variables ===");

    let sandbox = IsolateSandbox::new(1)
        .with_env_rule(EnvRule::Set("GREETING".to_string(), "Hello".to_string()))
        .with_env_rule(EnvRule::Set("NAME".to_string(), "Isolate".to_string()))
        .with_env_rule(EnvRule::Inherit("PATH".to_string()))
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_1.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Use environment variables in a bash command
    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo \"$GREETING, $NAME!\" && echo \"Current directory: $(pwd)\"",
            ],
            &limits,
        )
        .await?;

    println!("Output:\n{}", result.stdout);
    println!("Exit code: {:?}", result.exit_code);

    sandbox.cleanup().await?;
    println!("✓ Environment example completed\n");

    Ok(())
}

/// Example 3: File sharing between host and sandbox
async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}

pub async fn cleanup(&self) -> Result<()>

Cleanup the sandbox

Examples found in repository

examples/sandbox_usage.rs (line 84)

async fn basic_example() -> Result<()> {
    println!("=== Example 1: Basic Command Execution ===");

    // Create a sandbox with box ID 0
    let sandbox = IsolateSandbox::new(0)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_0.txt"))
        .verbose();

    // Initialize the sandbox
    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Run a simple echo command
    let result = sandbox
        .run("/bin/echo", ["Hello from Isolate Sandbox!"], &limits)
        .await?;

    println!("Exit code: {:?}", result.exit_code);
    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s", result.time_used);
    println!("Memory used: {} KB", result.memory_used);

    // Cleanup the sandbox
    sandbox.cleanup().await?;
    println!("✓ Basic example completed\n");

    Ok(())
}

/// Example 2: Using environment variables
async fn environment_example() -> Result<()> {
    println!("=== Example 2: Environment Variables ===");

    let sandbox = IsolateSandbox::new(1)
        .with_env_rule(EnvRule::Set("GREETING".to_string(), "Hello".to_string()))
        .with_env_rule(EnvRule::Set("NAME".to_string(), "Isolate".to_string()))
        .with_env_rule(EnvRule::Inherit("PATH".to_string()))
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_1.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Use environment variables in a bash command
    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo \"$GREETING, $NAME!\" && echo \"Current directory: $(pwd)\"",
            ],
            &limits,
        )
        .await?;

    println!("Output:\n{}", result.stdout);
    println!("Exit code: {:?}", result.exit_code);

    sandbox.cleanup().await?;
    println!("✓ Environment example completed\n");

    Ok(())
}

/// Example 3: File sharing between host and sandbox
async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}

pub fn with_directory_rule(self, rule: DirectoryRule) -> Self

The following are builder options.

Examples found in repository

examples/sandbox_usage.rs (line 140)

async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}

pub fn with_env_rule(self, rule: EnvRule) -> Self

Examples found in repository

examples/sandbox_usage.rs (line 95)

async fn environment_example() -> Result<()> {
    println!("=== Example 2: Environment Variables ===");

    let sandbox = IsolateSandbox::new(1)
        .with_env_rule(EnvRule::Set("GREETING".to_string(), "Hello".to_string()))
        .with_env_rule(EnvRule::Set("NAME".to_string(), "Isolate".to_string()))
        .with_env_rule(EnvRule::Inherit("PATH".to_string()))
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_1.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Use environment variables in a bash command
    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo \"$GREETING, $NAME!\" && echo \"Current directory: $(pwd)\"",
            ],
            &limits,
        )
        .await?;

    println!("Output:\n{}", result.stdout);
    println!("Exit code: {:?}", result.exit_code);

    sandbox.cleanup().await?;
    println!("✓ Environment example completed\n");

    Ok(())
}

/// Example 3: File sharing between host and sandbox
async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}

pub fn with_stdin(self, file: impl Into<String>) -> Self

pub fn with_stdout(self, file: impl Into<String>) -> Self

pub fn with_stderr(self, file: impl Into<String>) -> Self

pub fn with_stderr_to_stdout(self) -> Self

pub fn with_chdir(self, dir: impl Into<String>) -> Self

pub fn with_meta_file(self, file: impl Into<PathBuf>) -> Self

Examples found in repository

examples/sandbox_usage.rs (line 66)

async fn basic_example() -> Result<()> {
    println!("=== Example 1: Basic Command Execution ===");

    // Create a sandbox with box ID 0
    let sandbox = IsolateSandbox::new(0)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_0.txt"))
        .verbose();

    // Initialize the sandbox
    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Run a simple echo command
    let result = sandbox
        .run("/bin/echo", ["Hello from Isolate Sandbox!"], &limits)
        .await?;

    println!("Exit code: {:?}", result.exit_code);
    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s", result.time_used);
    println!("Memory used: {} KB", result.memory_used);

    // Cleanup the sandbox
    sandbox.cleanup().await?;
    println!("✓ Basic example completed\n");

    Ok(())
}

/// Example 2: Using environment variables
async fn environment_example() -> Result<()> {
    println!("=== Example 2: Environment Variables ===");

    let sandbox = IsolateSandbox::new(1)
        .with_env_rule(EnvRule::Set("GREETING".to_string(), "Hello".to_string()))
        .with_env_rule(EnvRule::Set("NAME".to_string(), "Isolate".to_string()))
        .with_env_rule(EnvRule::Inherit("PATH".to_string()))
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_1.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Use environment variables in a bash command
    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo \"$GREETING, $NAME!\" && echo \"Current directory: $(pwd)\"",
            ],
            &limits,
        )
        .await?;

    println!("Output:\n{}", result.stdout);
    println!("Exit code: {:?}", result.exit_code);

    sandbox.cleanup().await?;
    println!("✓ Environment example completed\n");

    Ok(())
}

/// Example 3: File sharing between host and sandbox
async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}

pub fn with_special_options(self, options: SpecialOptions) -> Self

pub fn use_cgroups(self) -> Self

pub fn disable_cgroups(self) -> Self

pub fn share_network(self) -> Self

pub fn no_default_dirs(self) -> Self

pub fn verbose(self) -> Self

Examples found in repository

examples/sandbox_usage.rs (line 67)

async fn basic_example() -> Result<()> {
    println!("=== Example 1: Basic Command Execution ===");

    // Create a sandbox with box ID 0
    let sandbox = IsolateSandbox::new(0)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_0.txt"))
        .verbose();

    // Initialize the sandbox
    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Run a simple echo command
    let result = sandbox
        .run("/bin/echo", ["Hello from Isolate Sandbox!"], &limits)
        .await?;

    println!("Exit code: {:?}", result.exit_code);
    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s", result.time_used);
    println!("Memory used: {} KB", result.memory_used);

    // Cleanup the sandbox
    sandbox.cleanup().await?;
    println!("✓ Basic example completed\n");

    Ok(())
}

/// Example 2: Using environment variables
async fn environment_example() -> Result<()> {
    println!("=== Example 2: Environment Variables ===");

    let sandbox = IsolateSandbox::new(1)
        .with_env_rule(EnvRule::Set("GREETING".to_string(), "Hello".to_string()))
        .with_env_rule(EnvRule::Set("NAME".to_string(), "Isolate".to_string()))
        .with_env_rule(EnvRule::Inherit("PATH".to_string()))
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_1.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Use environment variables in a bash command
    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo \"$GREETING, $NAME!\" && echo \"Current directory: $(pwd)\"",
            ],
            &limits,
        )
        .await?;

    println!("Output:\n{}", result.stdout);
    println!("Exit code: {:?}", result.exit_code);

    sandbox.cleanup().await?;
    println!("✓ Environment example completed\n");

    Ok(())
}

/// Example 3: File sharing between host and sandbox
async fn file_sharing_example() -> Result<()> {
    println!("=== Example 3: File Sharing ===");

    // Create a temporary directory on the host with proper permissions (0o755 = rwxr-xr-x)
    let host_dir = "/tmp/isolate_shared";
    create_dir_with_permissions(host_dir, 0o755).await?;
    println!("Created directory: {} with permissions 0755", host_dir);

    // Create a test file on the host
    let test_data = "This is data from the host system.\nLine 2\nLine 3";
    tokio::fs::write(format!("{}/input.txt", host_dir), test_data).await?;
    println!("Created input file at: {}/input.txt", host_dir);

    let sandbox = IsolateSandbox::new(2)
        .with_directory_rule(DirectoryRule::bind("/data", host_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_2.txt"))
        .verbose();

    let limits = ResourceLimits::new();
    sandbox.init(&limits).await?;

    // Read the file from within the sandbox
    println!("\n1. Reading file from sandbox:");
    let result = sandbox
        .run("/bin/cat", ["/data/input.txt"], &limits)
        .await?;
    println!("{}", result.stdout);

    // Write a new file from within the sandbox
    println!("2. Writing new file from sandbox:");
    let result = sandbox
        .run(
            "/bin/bash",
            ["-c", "echo 'Generated inside sandbox' > /data/output.txt && echo 'File written successfully'"],
            &limits,
        )
        .await?;
    println!("{}", result.stdout.trim());

    // Verify the file exists on the host
    let output_content = tokio::fs::read_to_string(format!("{}/output.txt", host_dir)).await?;
    println!("3. Content read back from host:");
    println!("{}", output_content.trim());

    sandbox.cleanup().await?;
    println!("✓ File sharing example completed\n");

    Ok(())
}

/// Example 4: Resource limits (time and memory)
async fn resource_limits_example() -> Result<()> {
    println!("=== Example 4: Resource Limits ===");

    let sandbox = IsolateSandbox::new(3)
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_3.txt"))
        .verbose();

    sandbox.init(&ResourceLimits::new()).await?;

    // Example 4a: Time limit
    println!("4a. Testing time limit (1 second):");
    let time_limits = ResourceLimits::new()
        .with_time_limit(1.0)
        .with_wall_time_limit(2.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Starting...'; sleep 5; echo 'Finished within time limit'",
            ],
            &time_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Time used: {:.3}s (limit: 1.0s)", result.time_used);
    println!("Killed: {}", result.killed);

    // Example 4b: Memory limit
    println!("\n4b. Testing memory limit (32 MB):");
    let memory_limits = ResourceLimits::new()
        .with_memory_limit(32 * 1024) // 32 MB
        .with_time_limit(5.0);

    let result = sandbox
        .run(
            "/bin/bash",
            [
                "-c",
                "echo 'Running with memory limit'; echo 'Memory limit: 32 MB'",
            ],
            &memory_limits,
        )
        .await?;

    println!("Output: {}", result.stdout.trim());
    println!("Memory used: {} KB (limit: 32768 KB)", result.memory_used);

    sandbox.cleanup().await?;
    println!("✓ Resource limits example completed\n");

    Ok(())
}

/// Example 5: Compile and run a C program
async fn compile_and_run_example() -> Result<()> {
    println!("=== Example 5: Compile and Run C Program ===");

    let shared_dir = "/tmp/isolate_c_example";
    create_dir_with_permissions(shared_dir, 0o777).await?;
    println!("Created directory: {} with permissions 0777", shared_dir);

    // Write a simple C program
    let c_code = r#"#include <stdio.h>

int main() {
    int sum = 0;
    for (int i = 1; i <= 10; i++) {
        sum += i;
    }
    printf("Sum of 1 to 10 is: %d\n", sum);
    printf("Program executed successfully!\n");
    return 0;
}
"#;

    tokio::fs::write(format!("{}/program.c", shared_dir), c_code).await?;
    println!("Created C source file at: {}/program.c", shared_dir);

    let sandbox = IsolateSandbox::new(4)
        .with_directory_rule(DirectoryRule::bind("/workspace", shared_dir).read_write())
        .with_meta_file(PathBuf::from("/tmp/isolate_meta_4.txt"))
        .with_env_rule(EnvRule::FullEnv)
        .verbose();

    let compile_limits = ResourceLimits::new()
        .with_time_limit(10.0)
        .with_memory_limit(256 * 1024); // 256 MB for compilation

    sandbox.init(&compile_limits).await?;

    // Compile the C program
    println!("\n1. Compiling C program:");
    let compile_result = sandbox
        .run(
            "/usr/bin/gcc",
            ["/workspace/program.c", "-o", "/workspace/program"],
            &compile_limits,
        )
        .await?;

    if compile_result.exit_code == Some(0) {
        println!("✓ Compilation successful!");
    } else {
        println!("✗ Compilation failed:");
        println!("stderr: {}", compile_result.stderr);
        sandbox.cleanup().await?;
        return Ok(());
    }

    // Run the compiled program
    println!("\n2. Running compiled program:");
    let run_limits = ResourceLimits::new()
        .with_time_limit(2.0)
        .with_memory_limit(64 * 1024) // 64 MB
        .with_process_limit(1);

    let run_result = sandbox
        .run("/workspace/program", Vec::<&str>::new(), &run_limits)
        .await?;

    println!("Output:\n{}", run_result.stdout);
    println!("Exit code: {:?}", run_result.exit_code);
    println!("Time used: {:.3}s", run_result.time_used);
    println!("Memory used: {} KB", run_result.memory_used);

    if run_result.killed {
        println!("⚠ Program was killed (exceeded limits)");
    }

    sandbox.cleanup().await?;
    println!("✓ Compile and run example completed\n");

    Ok(())
}