Struct DirectoryRule 

pub struct DirectoryRule {
    pub inside_path: PathBuf,
    pub outside_path: Option<PathBuf>,
    pub options: DirectoryOptions,
}

Directory binding rule

Fields

inside_path: PathBuf

outside_path: Option<PathBuf>

options: DirectoryOptions

Implementations

impl DirectoryRule

pub fn bind(inside: impl Into<PathBuf>, outside: impl Into<PathBuf>) -> Self

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 bind_same(path: impl Into<PathBuf>) -> Self

pub fn tmp(inside: impl Into<PathBuf>) -> Self

pub fn filesystem(name: impl Into<PathBuf>) -> Self

pub fn read_write(self) -> Self

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 allow_devices(self) -> Self

pub fn no_exec(self) -> Self

pub fn maybe(self) -> Self

pub fn no_recursive(self) -> Self

Trait Implementations

impl Clone for DirectoryRule

fn clone(&self) -> DirectoryRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DirectoryRule

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

Formats the value using the given formatter.