Guest /dev/fd links; jobs are told what they build c4285535b03a

    /// The state's hash on the hub (what checks are keyed by).

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

    pub state: String,

    /// The bookmark the run is for.

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

    pub bookmark: String,

    /// The run's number within its repository.

    #[serde(default)]

    pub run_number: i64,

}

impl Claim {

    /// What a job is told about what it builds (docs/m0.md §4):

    /// `FLOW_REPO`, `FLOW_STATE`, `FLOW_HEADS` (full hashes joined with

    /// `+`), `FLOW_BOOKMARK`, `FLOW_RUN` and `FLOW_JOB`. Unknown values are

    /// left out.

    pub fn flow_env(&self) -> Vec<(String, String)> {

        let mut v = vec![

            ("FLOW_REPO".to_string(), self.repo.clone()),

            ("FLOW_HEADS".to_string(), self.heads.join("+")),

            ("FLOW_JOB".to_string(), self.job.name.clone()),

        ];

        if !self.state.is_empty() {

            v.push(("FLOW_STATE".into(), self.state.clone()));

        }

        if !self.bookmark.is_empty() {

            v.push(("FLOW_BOOKMARK".into(), self.bookmark.clone()));

        }

        if self.run_number > 0 {

            v.push(("FLOW_RUN".into(), self.run_number.to_string()));

        }

        v

    }

impl Job {

    /// The job with variables that tell it what it builds (`FLOW_STATE`,

    /// `FLOW_BOOKMARK` …) added to its environment; a variable the pipeline

    /// sets itself keeps the pipeline's value.

    pub fn with_flow_env(&self, vars: &[(String, String)]) -> Job {

        let mut job = self.clone();

        for (k, v) in vars {

            job.env.entry(k.clone()).or_insert_with(|| v.clone());

        }

        job

    }

}

#[test]

fn jobs_are_told_what_they_build() {

    let p = Pipeline::parse(&doc(r#"job "build" {

    sandbox "alpine"

    env {

        FLOW_BOOKMARK "pinned-by-the-pipeline"

    }

    exec "make"

}"#))

    .unwrap();

    let job = p.jobs["build"].clone();

    let claim = crate::api::Claim {

        job_id: 7,

        run_id: 40,

        repo: "andy/demo".into(),

        clone_url: "https://hub/andy/demo".into(),

        token: "t".into(),

        heads: vec!["aa".into(), "bb".into()],

        pipeline_hash: "00".into(),

        job: job.clone(),

        sandbox: p.sandboxes["alpine"].clone(),

        timeout_s: 60,

        subrepos: vec![],

        state: "cc".into(),

        bookmark: "feature/x".into(),

        run_number: 3,

    };

    let env = job.with_flow_env(&claim.flow_env()).env;

    assert_eq!(env["FLOW_REPO"], "andy/demo");

    assert_eq!(env["FLOW_HEADS"], "aa+bb");

    assert_eq!(env["FLOW_STATE"], "cc");

    assert_eq!(env["FLOW_RUN"], "3", "the run's number in its repository, not the hub's id");

    assert_eq!(env["FLOW_JOB"], "build");

    assert_eq!(env["FLOW_BOOKMARK"], "pinned-by-the-pipeline", "the pipeline's own value wins");

    // Unknown values (an older hub) are left out, not empty.

    let old = crate::api::Claim { state: String::new(), bookmark: String::new(), run_number: 0, ..claim };

    let names: Vec<String> = old.flow_env().into_iter().map(|(k, _)| k).collect();

    assert_eq!(names, ["FLOW_REPO", "FLOW_HEADS", "FLOW_JOB"]);

}

/// The links every Linux system has under /dev and devtmpfs does not

/// make: `/dev/fd` (bash's process substitution, `<(…)`) and the standard

/// streams, all through the job's own /proc.

fn dev_links(dev: &str) -> Result<(), String> {

    for (name, target) in DEV_LINKS {

        let link = format!("{dev}/{name}");

        if std::fs::symlink_metadata(&link).is_err() {

            std::os::unix::fs::symlink(target, &link).map_err(|e| format!("link {link}: {e}"))?;

        }

    }

    Ok(())

}

const DEV_LINKS: [(&str, &str); 4] =

    [("fd", "/proc/self/fd"), ("stdin", "/proc/self/fd/0"), ("stdout", "/proc/self/fd/1"), ("stderr", "/proc/self/fd/2")];

    dev_links("/newroot/dev")?;

    use super::{dev_links, resolve_program};

    #[test]

    fn dev_gets_the_usual_links_once() {

        let dir = std::env::temp_dir().join(format!("flow-init-dev-{}", std::process::id()));

        let _ = std::fs::remove_dir_all(&dir);

        std::fs::create_dir_all(&dir).unwrap();

        let d = dir.to_str().unwrap();

        dev_links(d).unwrap();

        dev_links(d).unwrap();

        assert_eq!(std::fs::read_link(dir.join("fd")).unwrap(), std::path::Path::new("/proc/self/fd"));

        assert_eq!(std::fs::read_link(dir.join("stdout")).unwrap(), std::path::Path::new("/proc/self/fd/1"));

        // Through the host's /proc, the link works as in a job.

        assert!(dir.join("fd").join("0").exists() || !std::path::Path::new("/proc/self/fd/0").exists());

        std::fs::remove_dir_all(&dir).unwrap();

    }

        let job = &job.with_flow_env(&[("FLOW_JOB".into(), job.name.clone()), ("FLOW_RUN".into(), "local".into())]);

        let job = claim.job.with_flow_env(&claim.flow_env());

            &job,

   `/dev` gets the links devtmpfs lacks, `fd`, `stdin`, `stdout` and

   `stderr` into `/proc/self/fd`, so shell process substitution works. A job

   is told what it builds: `FLOW_REPO`, `FLOW_STATE` (the hub's state hash),

   `FLOW_HEADS` (full hashes joined with `+`), `FLOW_BOOKMARK`, `FLOW_RUN`

   (the run's number in its repository) and `FLOW_JOB`; `flow run` sets

   `FLOW_JOB` and `FLOW_RUN=local`. A variable the pipeline sets keeps its

   value. They are part of the job's environment, so of its receipt.