Struct SandboxResult 

pub struct SandboxResult {
    pub exit_code: i32,
    pub signal: Option<i32>,
    pub timed_out: bool,
    pub memory_peak: u64,
    pub cpu_time_us: u64,
    pub wall_time_ms: u64,
}

Sandbox execution result

Fields

exit_code: i32

Exit code

signal: Option<i32>

Signal that killed process (if any)

timed_out: bool

Whether timeout occurred

memory_peak: u64

Memory usage in bytes

cpu_time_us: u64

CPU time in microseconds

wall_time_ms: u64

Wall clock time in seconds

Implementations

impl SandboxResult

pub fn killed_by_seccomp(&self) -> bool

Check if process was killed by seccomp (SIGSYS - signal 31) Returns true if exit code is 159 (128 + 31)

pub fn seccomp_error(&self) -> Option<&'static str>

Get human-readable error message if process failed due to seccomp

pub fn check_seccomp_error(&self) -> Result<&SandboxResult>

Convert to Result, returning error if process was killed by seccomp

Examples found in repository

examples/stream_long_running.rs (line 71)

fn main() -> sandbox_rs::Result<()> {
    let tmp = tempdir().expect("Failed to create temp dir");

    let mut sandbox = SandboxBuilder::new("long-running-example")
        .memory_limit_str("512M")?
        .cpu_limit_percent(100)
        .timeout(Duration::from_secs(30))
        .seccomp_profile(SeccompProfile::Unrestricted)
        .root(tmp.path())
        .build()?;

    println!("Running bash script with streaming output...\n");

    // Run a bash script that outputs multiple lines
    let (result, stream) = sandbox.run_with_stream(
        "/bin/bash",
        &[
            "-c",
            "for i in {1..5}; do echo \"Line $i from stdout\"; echo \"Error line $i\" >&2; done",
        ],
    )?;

    println!("Streaming output:");

    let mut stdout_count = 0;
    let mut stderr_count = 0;
    let mut final_exit_code = result.exit_code;

    for chunk in stream.into_iter() {
        match chunk {
            StreamChunk::Stdout(line) => {
                stdout_count += 1;
                println!("  [OUT #{}] {}", stdout_count, line);
            }
            StreamChunk::Stderr(line) => {
                stderr_count += 1;
                eprintln!("  [ERR #{}] {}", stderr_count, line);
            }
            StreamChunk::Exit {
                exit_code,
                signal: _,
            } => {
                println!("Process finished with exit code: {}", exit_code);
                final_exit_code = exit_code;
            }
        }
    }

    let mut result = result;
    result.exit_code = final_exit_code;

    println!("\nSummary:");
    println!("  Stdout lines: {}", stdout_count);
    println!("  Stderr lines: {}", stderr_count);
    println!("  Wall time: {} ms", result.wall_time_ms);
    println!("  Exit code: {}", result.exit_code);

    result.check_seccomp_error()?;

    Ok(())
}

examples/stream_basic.rs (line 63)

fn main() -> sandbox_rs::Result<()> {
    // Create a temporary directory for the sandbox
    let tmp = tempdir().expect("Failed to create temp dir");

    // Create a sandbox with streaming enabled
    let mut sandbox = SandboxBuilder::new("stream-example")
        .memory_limit_str("256M")?
        .cpu_limit_percent(50)
        .timeout(Duration::from_secs(30))
        .root(tmp.path())
        .build()?;

    println!("Starting sandboxed process with streaming...\n");

    // Run process with streaming
    let (result, stream) = sandbox.run_with_stream("/bin/echo", &["Hello from sandbox!"])?;

    println!("Process output (streaming):");

    // Iterate through all output chunks
    let mut final_exit_code = result.exit_code;
    let mut final_signal = result.signal;

    for chunk in stream.into_iter() {
        match chunk {
            StreamChunk::Stdout(line) => {
                println!("[STDOUT] {}", line);
            }
            StreamChunk::Stderr(line) => {
                eprintln!("[STDERR] {}", line);
            }
            StreamChunk::Exit { exit_code, signal } => {
                println!("\nProcess exited with code: {}", exit_code);
                if let Some(sig) = signal {
                    println!("Killed by signal: {}", sig);
                }
                final_exit_code = exit_code;
                final_signal = signal;
            }
        }
    }

    // Update result with the actual exit code from streaming
    let mut result = result;
    result.exit_code = final_exit_code;
    result.signal = final_signal;

    println!("\nExecution stats:");
    println!("  Exit code: {}", result.exit_code);
    println!("  Wall time: {} ms", result.wall_time_ms);
    println!("  Memory peak: {} bytes", result.memory_peak);

    // Check for seccomp errors and return error if found
    result.check_seccomp_error()?;

    Ok(())
}

examples/stream_non_blocking.rs (line 89)

fn main() -> sandbox_rs::Result<()> {
    let tmp = tempdir().expect("Failed to create temp dir");

    let mut sandbox = SandboxBuilder::new("non-blocking-example")
        .memory_limit_str("256M")?
        .cpu_limit_percent(50)
        .seccomp_profile(SeccompProfile::Unrestricted)
        .root(tmp.path())
        .build()?;

    println!("Running process with non-blocking stream reads...\n");

    // Run a process that outputs slowly
    let (result, stream) = sandbox.run_with_stream(
        "/bin/bash",
        &[
            "-c",
            "for i in {1..3}; do echo \"Message $i\"; sleep 0.1; done",
        ],
    )?;

    println!("Non-blocking polling:");

    let mut received_chunks = 0;
    let mut polling_attempts = 0;
    let mut final_exit_code = result.exit_code;

    loop {
        polling_attempts += 1;

        // Try to read without blocking
        match stream.try_recv()? {
            Some(chunk) => match chunk {
                StreamChunk::Stdout(line) => {
                    println!("[STDOUT] {}", line);
                    received_chunks += 1;
                }
                StreamChunk::Stderr(line) => {
                    eprintln!("[STDERR] {}", line);
                    received_chunks += 1;
                }
                StreamChunk::Exit {
                    exit_code,
                    signal: _,
                } => {
                    println!("Process exited with code: {}", exit_code);
                    // Capture the real exit code from the stream
                    final_exit_code = exit_code;
                    break;
                }
            },
            None => {
                // No data available right now, we could do other work here
                std::thread::sleep(Duration::from_millis(10));
            }
        }

        // Safety limit to prevent infinite loop in case of issues
        if polling_attempts > 10000 {
            println!("Safety timeout reached");
            break;
        }
    }

    // Update result with the actual exit code from streaming
    let mut result = result;
    result.exit_code = final_exit_code;

    println!("\nStatistics:");
    println!("  Chunks received: {}", received_chunks);
    println!("  Polling attempts: {}", polling_attempts);
    println!("  Exit code: {}", result.exit_code);
    println!("  Wall time: {} ms", result.wall_time_ms);

    // Check for seccomp errors and return error if found
    result.check_seccomp_error()?;

    Ok(())
}

Trait Implementations

impl Clone for SandboxResult

fn clone(&self) -> SandboxResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SandboxResult

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

Formats the value using the given formatter.