runnerctl 0.3.0

Manage independent ephemeral GitHub Actions runner pools on one Docker host
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

// Unix only: the fake docker is a shell script, and one client connects to the socket directly.
#![cfg(unix)]
use assert_cmd::Command;
use serde_json::Value;
use std::{
    fs,
    os::unix::{fs::PermissionsExt, net::UnixStream},
    path::Path,
    process::{Child, Stdio},
    time::{Duration, Instant},
};

struct Manager(Child);
impl Drop for Manager {
    fn drop(&mut self) {
        let _ = self.0.kill();
        let _ = self.0.wait();
    }
}
fn cli(home: &Path) -> Command {
    let mut command = Command::new(assert_cmd::cargo::cargo_bin!("runnerctl"));
    command
        .arg("--home")
        .arg(home)
        .timeout(Duration::from_secs(2));
    command
}
fn wait_for(path: &Path) {
    let deadline = Instant::now() + Duration::from_secs(5);
    while !path.exists() {
        assert!(
            Instant::now() < deadline,
            "{} was not created",
            path.display()
        );
        std::thread::sleep(Duration::from_millis(10));
    }
}
fn start_manager(home: &Path, bin: &Path, marker: &Path) -> Manager {
    let child = std::process::Command::new(assert_cmd::cargo::cargo_bin!("runnerctl"))
        .args(["--home", home.to_str().unwrap(), "manager"])
        .env(
            "PATH",
            format!("{}:{}", bin.display(), std::env::var("PATH").unwrap()),
        )
        .env("RUNNERCTL_TEST_MARKER", marker)
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn()
        .unwrap();
    wait_for(&home.join("manager.sock"));
    Manager(child)
}
fn fake_docker(bin: &Path, body: &str) {
    fs::create_dir_all(bin).unwrap();
    let path = bin.join("docker");
    fs::write(&path, format!("#!/bin/sh\nset -eu\n{body}\n")).unwrap();
    fs::set_permissions(path, fs::Permissions::from_mode(0o700)).unwrap();
}

#[test]
fn slow_reconciliation_accepts_stop_and_does_not_provision_from_stale_intent() {
    let dir = tempfile::tempdir().unwrap();
    let home = dir.path().join("state");
    let bin = dir.path().join("bin");
    let marker = dir.path().join("slow-operation");
    fake_docker(
        &bin,
        "if [ \"$1\" = ps ]; then touch \"$RUNNERCTL_TEST_MARKER\"; sleep 3; exit 0; fi\nexit 1",
    );
    cli(&home)
        .args(["init", "--org", "example"])
        .assert()
        .success();
    cli(&home)
        .args([
            "pool", "add", "test", "--org", "example", "--auth", "example", "--labels", "test",
        ])
        .assert()
        .success();
    cli(&home).args(["start", "test"]).assert().success();
    let _manager = start_manager(&home, &bin, &marker);
    wait_for(&marker);
    let started = Instant::now();
    cli(&home)
        .args(["stop", "test", "--wait", "--timeout", "1s"])
        .assert()
        .success();
    assert!(started.elapsed() < Duration::from_secs(2));
    std::thread::sleep(Duration::from_millis(3200));
    let output = cli(&home).args(["--json", "status"]).output().unwrap();
    assert!(output.status.success());
    let status: Value = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(status["pools"][0]["intent"], "stopped");
    assert_eq!(status["pools"][0]["active"], 0);
    assert_eq!(status["pools"][0]["error"], Value::Null);
}

#[test]
fn slow_doctor_and_incomplete_client_do_not_block_status() {
    let dir = tempfile::tempdir().unwrap();
    let home = dir.path().join("state");
    let bin = dir.path().join("bin");
    let marker = dir.path().join("slow-doctor");
    fake_docker(
        &bin,
        "touch \"$RUNNERCTL_TEST_MARKER\"\nsleep 3\nprintf 'test-daemon\\n'",
    );
    cli(&home)
        .args(["init", "--org", "example"])
        .assert()
        .success();
    let _manager = start_manager(&home, &bin, &marker);
    let _incomplete_client = UnixStream::connect(home.join("manager.sock")).unwrap();
    let mut doctor = std::process::Command::new(assert_cmd::cargo::cargo_bin!("runnerctl"))
        .args(["--home", home.to_str().unwrap(), "doctor"])
        .stdout(Stdio::null())
        .stderr(Stdio::null())
        .spawn()
        .unwrap();
    wait_for(&marker);
    let started = Instant::now();
    cli(&home).arg("status").assert().success();
    assert!(started.elapsed() < Duration::from_secs(2));
    assert!(doctor.wait().unwrap().success());
}