runnerd-core 0.0.19

Config, domain logic and API types shared by runnerd and its clients
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
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

//! What every client says a slot does, and how it counts whether CI keeps up.

use crate::api::{
    Activity, Budget, ProfileStatus, QueuedJob, RunnerStatus, SlotStatus, Status, Tone,
};

fn runner(busy: bool, warm: bool) -> RunnerStatus {
    RunnerStatus {
        repository: "o/app".to_owned(),
        name: "runnerd-jvm".to_owned(),
        runner_id: 1,
        container: "c".to_owned(),
        busy,
        started_at: 0,
        reserved: 0,
        warm,
    }
}

/// `jvm`, reseeding, with an empty slot 1, a busy, a starting and a warm runner.
fn status() -> Status {
    let slots = [
        None,
        Some(runner(true, false)),
        Some(runner(false, false)),
        Some(runner(false, true)),
    ];
    Status {
        version: "0.0.0".to_owned(),
        shutting_down: false,
        budget: Budget::default(),
        profiles: vec![ProfileStatus {
            name: "jvm".to_owned(),
            image: "runnerd-runner:base".to_owned(),
            cpus: 4,
            memory: 1 << 30,
            reseeding: true,
            slots: slots
                .into_iter()
                .enumerate()
                .map(|(index, runner)| SlotStatus {
                    slot: index + 1,
                    runner,
                })
                .collect(),
        }],
        repositories: vec![],
        queued: [100, 0, 40]
            .into_iter()
            .map(|queued_at| QueuedJob {
                id: queued_at,
                repository: "o/app".to_owned(),
                profile: None,
                run_id: 1,
                run_attempt: 1,
                workflow: None,
                name: "build".to_owned(),
                branch: None,
                url: None,
                queued_at,
                waiting: None,
            })
            .collect(),
    }
}

#[test]
fn a_runner_waiting_for_work_is_starting_or_warm_never_idle() {
    let status = status();
    let profile = &status.profiles[0];
    let lines: Vec<String> = profile
        .slots
        .iter()
        .map(|slot| Status::slot_state(profile, slot).line())
        .collect();
    assert_eq!(
        lines,
        [
            "reseeding the snapshot",
            "running a job of o/app",
            "a runner for o/app waiting for its job",
            "a warm runner for o/app, waiting for a job",
        ]
    );
    assert_eq!(
        Status::slot_state(profile, &profile.slots[2]).word(),
        "starting"
    );
}

#[test]
fn health_counts_runners_by_what_github_reports_not_by_found_job_details() {
    let health = status().health(160);
    assert_eq!(
        (health.slots, health.running, health.starting, health.warm),
        (4, 1, 1, 1)
    );
    assert_eq!(health.waiting, 3, "a job without a queue time still waits");
    assert_eq!(
        health.oldest_wait,
        Some(120),
        "the oldest known queue time, at 40"
    );
    assert_eq!(health.waiting_tone(), Tone::Warn);
}

#[test]
fn the_days_failures_are_bad_only_when_a_runner_failed() {
    let mut day = Activity {
        since: 0,
        until: 86_400,
        started: vec![],
        finished: 10,
        failed: 3,
        runner_failed: 0,
    };
    assert_eq!(day.failed_tone(), Tone::Neutral, "the jobs' own failures");
    day.runner_failed = 1;
    assert_eq!(day.failed_tone(), Tone::Bad);
}