pipeline.kdl: timeout on a job or a sandbox 02b127d2c721

- **A job says how long it may run (#23).** `timeout "90m"` on a job, or on a sandbox for its jobs (hours, minutes, seconds; a minute to a day). The hub caps it at the site's maximum.

- **A pinned file is re-read from the disk before its hash is called wrong (#22).**

    /// How long each job here may run, in seconds (`timeout "2h"`), when

    /// the job does not say; the hub caps it at the site's maximum.

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub timeout_s: Option<u64>,

    /// How long the job may run, in seconds (`timeout "90m"`); its

    /// sandbox's when absent, else the site's default (oxygenflow#23).

    #[serde(default, skip_serializing_if = "Option::is_none")]

    pub timeout_s: Option<u64>,

        job.timeout_s = job.timeout_s.or(sandbox.timeout_s);

    let mut timeout_s = None;

            "timeout" => timeout_s = parse_timeout(ctx, c),

    Some(Sandbox { name, runtime: runtime?, rootfs: rootfs?, memory_mib: memory?, cpus: cpus?, network: network?, env, runs_on, timeout_s })

/// The longest a pipeline may ask a job to run.

pub const MAX_TIMEOUT_S: u64 = 24 * 3600;

/// A duration: whole hours, minutes and seconds in that order, each

/// optional, as "90m", "2h", "1h30m" or "45s".

pub fn parse_duration(s: &str) -> Option<u64> {

    let (mut total, mut num, mut last) = (0u64, String::new(), 0u8);

    for ch in s.chars() {

        if ch.is_ascii_digit() {

            num.push(ch);

            continue;

        }

        let (unit, mult) = match ch {

            'h' => (1, 3600),

            'm' => (2, 60),

            's' => (3, 1),

            _ => return None,

        };

        // Each unit once, largest first, each with its number.

        if num.is_empty() || unit <= last {

            return None;

        }

        last = unit;

        total = total.checked_add(num.parse::<u64>().ok()?.checked_mul(mult)?)?;

        num.clear();

    }

    (num.is_empty() && total > 0).then_some(total)

}

/// A `timeout` line: one duration, from a minute to a day.

fn parse_timeout(ctx: &mut Ctx, c: &KdlNode) -> Option<u64> {

    let t = ctx.one_string(c)?;

    match parse_duration(&t) {

        Some(secs) if (60..=MAX_TIMEOUT_S).contains(&secs) => Some(secs),

        Some(_) => {

            ctx.err(c.span(), format!("timeout {t:?} must be from 1m to 24h"));

            None

        }

        None => {

            ctx.err(c.span(), format!("timeout {t:?}: expected hours, minutes and seconds, as \"90m\" or \"1h30m\""));

            None

        }

    }

}

        timeout_s: None,

            }

            "timeout" => {

                ctx.no_children(c);

                job.timeout_s = parse_timeout(ctx, c);

/// oxygenflow#23: `timeout` on a job, or on its sandbox for every job in

/// it, as a duration from a minute to a day.

#[test]

fn a_job_says_how_long_it_may_run() {

    use crate::pipeline::{parse_duration, Pipeline};

    assert_eq!(parse_duration("90m"), Some(5400));

    assert_eq!(parse_duration("1h30m"), Some(5400));

    assert_eq!(parse_duration("2h"), Some(7200));

    assert_eq!(parse_duration("45s"), Some(45));

    for bad in ["", "90", "m", "30m1h", "1h1h", "2d", "-1h"] {

        assert_eq!(parse_duration(bad), None, "{bad:?}");

    }

    let root = "a".repeat(64);

    let text = format!(

        "schema-version 1\nsandbox \"s\" {{\n    runtime \"microvm\"\n    rootfs \"cas://blob/{root}\"\n    memory-limit \"1GiB\"\n    cpu-limit 1\n    network \"isolated\"\n    timeout \"2h\"\n}}\njob \"long\" {{\n    sandbox \"s\"\n    timeout \"3h30m\"\n    exec \"true\"\n}}\njob \"plain\" {{\n    sandbox \"s\"\n    exec \"true\"\n}}\n"

    );

    let p = Pipeline::parse(&text).unwrap();

    let job = |n: &str| p.jobs[n].in_sandbox(&p.sandboxes["s"]);

    assert_eq!(job("long").timeout_s, Some(12600), "the job's own");

    assert_eq!(job("plain").timeout_s, Some(7200), "the sandbox's");

    let bad = text.replace("timeout \"3h30m\"", "timeout \"2d\"");

    assert!(Pipeline::parse(&bad).unwrap_err().to_string().contains("timeout"));

    let long = text.replace("timeout \"3h30m\"", "timeout \"25h\"");

    assert!(Pipeline::parse(&long).unwrap_err().to_string().contains("from 1m to 24h"));

}

            timeout_s: None,

**Time limits.** A job may say how long it may run with `timeout "90m"` (hours, minutes and seconds, as `"2h"`, `"1h30m"` or `"45s"`, from a minute to a day); a sandbox's `timeout` is the default for its jobs. Without one, the hub's default applies, and the hub caps every job at the site's maximum (both set by an administrator on Admin → Runners). The runner stops a job at its limit, and the hub ends one its runner stopped reporting a few minutes after it. A timeout is part of the compiled job, so a job without one compiles as before.