Pipelines: runs-on asks for runner labels (refs andymccall/oxygenhub#41, part 3) e576e08617dc

    /// Labels a runner must have to run jobs here (`runs-on`), sorted.

    #[serde(default, skip_serializing_if = "Vec::is_empty")]

    pub runs_on: Vec<String>,

    /// Labels a runner must have to take this job (`runs-on`), sorted;

    /// with its sandbox's, what the hub matches against a runner's.

    #[serde(default, skip_serializing_if = "Vec::is_empty")]

    pub runs_on: Vec<String>,

        job.runs_on.extend(sandbox.runs_on.iter().cloned());

        job.runs_on.sort();

        job.runs_on.dedup();

    let mut runs_on = Vec::new();

        if key != "runs-on" && !seen.insert(key.to_string()) {

        if key == "runs-on" {

            ctx.no_children(c);

            parse_labels(ctx, c, &mut runs_on);

            continue;

        }

    }

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

}

/// The labels of a `runs-on` line: lower-case letters, digits, `-`, `_`

/// and `.`, at most 64 bytes each; into `into`, sorted, once each.

fn parse_labels(ctx: &mut Ctx, c: &KdlNode, into: &mut Vec<String>) {

    let labels = ctx.strings(c);

    if labels.is_empty() {

        ctx.err(c.span(), "`runs-on` needs one or more labels, as runs-on \"riscv64\"");

    for l in labels {

        let ok = !l.is_empty()

            && l.len() <= 64

            && l.bytes().all(|b| b.is_ascii_lowercase() || b.is_ascii_digit() || matches!(b, b'-' | b'_' | b'.'));

        if ok {

            into.push(l);

        } else {

            ctx.err(c.span(), format!("runs-on {l:?}: a label is lower-case letters, digits, -, _ and ., at most 64"));

        }

    }

    into.sort();

    into.dedup();

        runs_on: vec![],

        if key != "scope" && key != "depends-on" && key != "mount" && key != "runs-on" && !seen.insert(key.to_string()) {

            }

            "runs-on" => {

                ctx.no_children(c);

                parse_labels(ctx, c, &mut job.runs_on);

#[test]

fn runs_on_asks_for_runner_labels() {

    let src = doc("job \"cross\" {\n    sandbox \"alpine\"\n    runs-on \"riscv64\" \"big-disk\"\n    exec \"make\"\n}\n")

        .replace("    network", "    runs-on \"gpu\"\n    network");

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

    let job = &p.jobs["cross"];

    assert_eq!(job.runs_on, vec!["big-disk", "riscv64"], "sorted");

    let sandbox = &p.sandboxes["alpine"];

    assert_eq!(sandbox.runs_on, vec!["gpu"]);

    assert_eq!(job.in_sandbox(sandbox).runs_on, vec!["big-disk", "gpu", "riscv64"], "with its sandbox's");

    // A pipeline without runs-on serialises as before, so its jobs' hashes stay.

    let plain = Pipeline::parse(&doc("job \"x\" {\n    sandbox \"alpine\"\n    exec \"true\"\n}\n")).unwrap();

    assert!(!serde_json::to_string(&plain.jobs["x"]).unwrap().contains("runs_on"));

    let bad = problems(&doc("job \"x\" {\n    sandbox \"alpine\"\n    runs-on \"RISCV\"\n    exec \"true\"\n}\n"));

    assert!(bad.iter().any(|(_, m)| m.contains("a label is lower-case")), "{bad:?}");

    let none = problems(&doc("job \"y\" {\n    sandbox \"alpine\"\n    runs-on\n    exec \"true\"\n}\n"));

    assert!(none.iter().any(|(_, m)| m.contains("needs one or more labels")), "{none:?}");

}

            runs_on: vec![],

**Runner labels.** A sandbox or a job may say `runs-on "LABEL" ...`: lower-case letters, digits, `-`, `_` and `.`, at most 64 bytes each, given on one or more lines. A job needs a runner that has every label its sandbox and it name. A runner reports its labels and architecture when it registers and on each claim (`flow runner register --label`). The hub hands a job only to a runner with all of them, within the runner's scope (OxygenHub spec 13.2), and a job no runner can take waits, saying so on the queue. Labels are part of the compiled job, so a job that asks for none compiles as before.