Artifacts: when "always" keeps a failing job's report 9a6fac2b40a9

    /// `when "always"`: kept from a failing job too, such as a test report

    /// (oxygenflow#37). From a failing job it is never in the receipt.

    #[serde(default, skip_serializing_if = "std::ops::Not::not")]

    pub always: bool,

        let mut always = false;

                "when" => match ctx.one_string(c).as_deref() {

                    Some("passed") => always = false,

                    Some("always") => always = true,

                    Some(_) => ctx.err(c.span(), "artifact `when` is \"passed\" (the default) or \"always\""),

                    None => {}

                },

            job.outputs.push(Output { name, path, always });

    // oxygenflow#37: `when "always"` keeps a failing job's report; the

    // default hashes and serialises as before.

    let p = Pipeline::parse(&src(

        "    output {\n        artifact \"junit\" {\n            path \"/src/target/junit.xml\"\n            when \"always\"\n        }\n        artifact \"tool\" {\n            path \"/src/target/tool\"\n            when \"passed\"\n        }\n    }\n",

    ))

    .unwrap();

    let outs = &p.jobs["build"].outputs;

    assert!(outs[0].always && outs[0].name == "junit");

    assert!(!outs[1].always);

    let json = serde_json::to_string(&outs[1]).unwrap();

    assert!(!json.contains("always"), "{json}");

    assert!(serde_json::to_string(&outs[0]).unwrap().contains("\"always\":true"));

    assert!(bad("    output {\n        artifact \"x\" {\n            path \"/src/a\"\n            when \"failed\"\n        }\n    }\n")

        .contains("\"passed\" (the default) or \"always\""));

        // declared artifact that cannot be kept fails the job. A failing

        // job keeps only its `when "always"` ones (oxygenflow#37), outside

        // its receipt, and one it cannot keep is only noted.

        let passed = outcome.exit_code == Some(0);

        let wanted = claim.job.outputs.iter().filter(|o| passed || o.always);

        for o in wanted {

            let read = if syscall_tier {

                let (dir, inner) = crate::outputs::locate_dir(&claim.job, &scratch.join("tree"), &scratch, &o.path);

                crate::outputs::read_dir_file(&dir, &inner)

            } else {

                let (image, inner) = crate::outputs::locate(&claim.job, &scratch.join("workspace.ext4"), &scratch, &o.path);

                crate::outputs::read(&image, &inner, &scratch)

            };

            let kept = read.and_then(|bytes| {

                let blob = Repo::blob_ref(&bytes);

                let named = hub.artifact(claim.job_id, &o.name, &bytes)?;

                if named != blob.to_hex() {

                    bail!("the hub kept it as {named}, not {}", blob.to_hex());

                }

                let unattested = if passed { "" } else { " (the job failed: not in its receipt)" };

                note(&mut sink, format!("artifact {}: {} bytes, blob {}{unattested}", o.name, bytes.len(), &named[..12]));

                Ok(blob.0)

            });

            match kept {

                Ok(b) if passed => outputs.push(b),

                Ok(_) => {}

                Err(e) if passed => {

                    output_error = Some(format!("artifact {}: {e:#}", o.name));

                    break;

                Err(e) => note(&mut sink, format!("artifact {}: not kept: {e:#}", o.name)),

4. Outputs are read when the job passes. An artifact with `when "always"`

   (default `when "passed"`) is also read when the job fails or is stopped

   at its time limit, so a test report survives the failure it describes.

   From a job that did not pass it is kept and shown, but its receipt never

   names it, and one that cannot be read is only noted in the log.

```kdl

output {

    artifact "junit" {

        path "/src/target/junit.xml"

        when "always"

    }

}

```