bupha-dagger 0.1.0

Runner impl: `dagger call <fn>` per job
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

//! bupha-runner-dagger — `dagger call <fn>` in the worktree. Dagger (and
//! its container engine) is only needed when this runner is selected;
//! the port knows nothing about it.

use bupha_runner::{RunCtx, RunHandle, Runner};
use serde::Deserialize;
use std::io;
use std::process::Command;

/// dagger runner config — impl-owned fields, deserialized from
/// `runner.extra`.
#[derive(Debug, Deserialize)]
pub struct DaggerCfg {
    #[serde(default = "crate::default_function")]
    pub function: String,
    #[serde(default = "crate::default_shards")]
    pub shards: String,
    #[serde(default = "crate::default_jobs")]
    pub jobs: String,
    #[serde(default)]
    pub dogfood_jobs: String,
    #[serde(default)]
    pub sequential: bool,
    /// sccache conf passed as `--sccache-conf` (resolved from
    /// `[cache]` by the composition root).
    #[serde(default)]
    pub sccache_conf: Option<String>,
    #[serde(default)]
    pub cli_source: Option<String>,
    #[serde(default)]
    pub extra_args: Vec<String>,
}

fn default_function() -> String {
    "ci".into()
}
fn default_shards() -> String {
    "1".into()
}
fn default_jobs() -> String {
    "1".into()
}

pub struct DaggerRunner {
    cfg: DaggerCfg,
    /// `--cli-source <dir>` — for repos whose pipeline builds
    /// against a sibling checkout.
    cli_source: Option<String>,
}

impl DaggerRunner {
    pub fn new(cfg: DaggerCfg, cli_source: Option<String>) -> Self {
        Self { cfg, cli_source }
    }
}

impl Runner for DaggerRunner {
    fn name(&self) -> &'static str {
        "dagger"
    }

    fn spawn(&self, ctx: &RunCtx) -> io::Result<Box<dyn RunHandle>> {
        let c = &self.cfg;
        let mut cmd = Command::new("dagger");
        // Flags beyond shards/jobs/token are only emitted when set —
        // `dagger call` rejects args the module's function doesn't
        // declare, so the emitted set must match the module signature.
        cmd.current_dir(ctx.workdir).args([
            "call",
            &c.function,
            "--shards",
            &c.shards,
            "--jobs",
            &c.jobs,
            "--token",
            &format!("env://{}", ctx.token_env),
        ]);
        if !c.dogfood_jobs.is_empty() {
            cmd.args(["--dogfood-jobs", &c.dogfood_jobs]);
        }
        if let Some(conf) = c.sccache_conf.as_deref() {
            cmd.args(["--sccache-conf", &format!("file://{conf}")]);
        }
        if c.sequential {
            cmd.arg("--sequential");
        }
        if let Some(src) = &self.cli_source {
            cmd.args(["--cli-source", src]);
        }
        cmd.args(&c.extra_args);
        cmd.spawn().map(|c| Box::new(c) as Box<dyn RunHandle>)
    }
}