Struct RunCommandRequest 

pub struct RunCommandRequest {
    pub command: String,
    pub args: Vec<String>,
    pub cwd: Option<String>,
    pub env: BTreeMap<String, String>,
    pub timeout: Duration,
}

A command to run inside a sandbox.

Fields

command: String

The program to run

args: Vec<String>

Arguments handed to the program, each as one argument — nothing re-parses their text

cwd: Option<String>

Working directory inside the sandbox

env: BTreeMap<String, String>

Environment overlaid on the sandbox’s own

timeout: Duration

How long this command may run. Required — a defaulted timeout is a hang waiting for a slow day.

CreateSandboxRequest::timeout_ms is an outer bound this timeout cannot see. Neither shortens the other, but on AWS and GCP the platform reaps the sandbox at its lifetime whatever is running inside: a command still going is cut off mid-flight and reports SANDBOX_OUTCOME_UNKNOWN, never timeoutExceeded, because nothing survived to say what it did. A lifetime has to leave room for the longest command it must cover.

It bounds the command, not the call, and the call lands just after it. Where the agent supervises the process it kills the process group; where the data plane has no timeout of its own the command runs under timeout inside the sandbox. Either way the sandbox stays usable. Only a sandbox that cannot run timeout is ended instead, and that call returns once the sandbox is gone.

On every backend timeoutExceeded is reported only once the command has verifiably stopped — the agent waits for its kill, and where there is no agent the sandbox kills the command itself and says so. It is never reported on a stop that was merely requested: a timeout that leaves untrusted code running is not a timeout.

What stops is the command and its process group. A descendant that detaches itself into a session of its own is beyond any signal sent from inside, on every backend; it is bounded by the sandbox, which ends on terminate or at its own lifetime ceiling.

Implementations

impl RunCommandRequest

pub fn argv(&self) -> Vec<String>

The program followed by its arguments, which is the shape every backend’s exec takes.

Trait Implementations

impl Clone for RunCommandRequest

fn clone(&self) -> RunCommandRequest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RunCommandRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RunCommandRequest

fn deserialize<__D>( __deserializer: __D, ) -> Result<RunCommandRequest, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for RunCommandRequest

impl PartialEq for RunCommandRequest

fn eq(&self, other: &RunCommandRequest) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for RunCommandRequest

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RunCommandRequest