Struct StartRequest 

pub struct StartRequest {
    pub exec_id: String,
    pub command: Vec<String>,
    pub shell: bool,
    pub cwd: Option<String>,
    pub env: HashMap<String, String>,
    pub user: Option<u32>,
    pub group: Option<u32>,
    pub timeout_sec: Option<f64>,
    pub stdin: bool,
    pub reap_group_on_exit: bool,
}

A start request. command is either an argv array or, with shell: true, a single script string.

Fields

exec_id: String

Caller-minted idempotency key. Harbor retries, and a retry must not produce a second child.

command: Vec<String>

argv when shell is false, or the script when it is true.

shell: bool

cwd: Option<String>

Omitted means inherit the daemon’s working directory. See the module docs.

env: HashMap<String, String>

user: Option<u32>

Numeric uid to demote to. Optional; omitted means run as the daemon’s own user.

group: Option<u32>

timeout_sec: Option<f64>

Wall-clock budget. Validated before the child spawns — the predecessor raised on a bad value inside the waiter thread, by which point the child was already running and became an orphan.

stdin: bool

Whether to give the child a writable stdin pipe. Defaults to false, which keeps Stdio::null().

Opt-in rather than always-on, and not only for tidiness: a child holding an open stdin pipe nobody will ever write to is a child that blocks forever the first time it reads. /bin/sh reading a script from stdin, git deciding it can prompt, any tool that probes for input — all of them behave differently against a pipe than against /dev/null. Every existing caller gets today’s behavior by not setting this.

reap_group_on_exit: bool

Whether to signal the exec’s whole process group once its own child exits.

Off by default, and the default is the contract this daemon has always had: a backgrounded grandchild that inherited the output pipe keeps running and keeps writing, and the linger deadline is what bounds how long the daemon waits on it. That is the “backgrounded server keeps logging” guarantee, and callers rely on it. Set to true, the daemon runs the same SIGTERM-then- SIGKILL escalation POST /v1/exec/{id}/kill uses against the group as soon as the child’s exit is observed, so nothing the command left behind outlives it and the linger sees EOF rather than writers_may_be_alive. A timed-out exec is already escalated and is not escalated twice.

Trait Implementations

impl Debug for StartRequest

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StartRequest

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for StartRequest

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for StartRequest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.