pipeline.kdl: priority lowers a job's place in the queue, never raises it e87c1c138187

    /// `low` or `normal` (`priority "low"`, or the pipeline's): a pipeline

    /// may lower its jobs below the repository's level, never raise them

    /// (oxygenhub#244); higher levels are the hub's to give.

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

    pub priority: Option<String>,

        let mut priority = None;

                "priority" => {

                    if priority.is_some() {

                        ctx.err(node.span(), "`priority` is given twice");

                    }

                    priority = parse_priority(&mut ctx, node);

                }

                n => ctx.err(node.span(), format!("unknown node `{n}`; expected schema-version, on, priority, sandbox or job")),

        // The pipeline's priority is each job's that does not say.

        let jobs = jobs

            .into_iter()

            .map(|(k, (mut j, _))| {

                if j.priority.is_none() {

                    j.priority.clone_from(&priority);

                }

                (k, j)

            })

            .collect();

        Ok(Pipeline { schema_version: 1, sandboxes, jobs, on })

/// `priority "low"`: a pipeline may lower its jobs, never raise them

/// (oxygenhub#244).

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

    ctx.no_children(c);

    let p = ctx.one_string(c)?;

    match p.as_str() {

        "low" | "normal" => Some(p),

        "high" | "urgent" => {

            ctx.err(

                c.span(),

                format!("priority {p:?}: a pipeline may lower its jobs (`low`, `normal`), not raise them; higher levels are set on the hub, and a person may expedite a run"),

            );

            None

        }

        _ => {

            ctx.err(c.span(), format!("priority {p:?}: expected `low` or `normal`"));

            None

        }

    }

}

        priority: None,

            "priority" => job.priority = parse_priority(ctx, c),

/// oxygenhub#244: a pipeline may lower its jobs' priority, for all of them

/// or one by one, never raise it.

#[test]

fn a_pipeline_lowers_its_jobs_priority_and_never_raises_it() {

    let jobs = "job \"nightly\" {\n    sandbox \"alpine\"\n    exec \"true\"\n}\njob \"check\" {\n    sandbox \"alpine\"\n    priority \"normal\"\n    exec \"true\"\n}\n";

    let p = Pipeline::parse(&format!("priority \"low\"\n{}", doc(jobs))).unwrap();

    assert_eq!(p.jobs["nightly"].priority.as_deref(), Some("low"), "the pipeline's");

    assert_eq!(p.jobs["check"].priority.as_deref(), Some("normal"), "its own");

    let one = Pipeline::parse(&doc("job \"a\" {\n    sandbox \"alpine\"\n    priority \"low\"\n    exec \"true\"\n}\n")).unwrap();

    assert_eq!(one.jobs["a"].priority.as_deref(), Some("low"));

    // None given: serialised 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("priority"));

    for high in ["high", "urgent"] {

        let bad = problems(&doc(&format!("job \"x\" {{\n    sandbox \"alpine\"\n    priority \"{high}\"\n    exec \"true\"\n}}\n")));

        assert!(bad.iter().any(|(_, m)| m.contains("not raise them")), "{high}: {bad:?}");

    }

    let odd = problems(&doc("job \"x\" {\n    sandbox \"alpine\"\n    priority \"soon\"\n    exec \"true\"\n}\n"));

    assert!(odd.iter().any(|(_, m)| m.contains("expected `low` or `normal`")), "{odd:?}");

}

            priority: None,

**Priority.** A pipeline may lower its jobs' place in the hub's queue, never raise it (oxygenhub#244): `priority "low"` (or `"normal"`) on a job, or at the top of the file for every job that does not say. A job's level is then the lower of its own and its repository's (the repository's, organisation's or site's, set on the hub), so nightly or bulk jobs can stand back for everyday ones; `high` and `urgent` are refused here, being the hub's to give, and a run a person expedites stays urgent whatever its jobs say. A priority is part of the compiled job; a job without one compiles as before.