scaleset 0.2.0

Autoscale GitHub Actions self-hosted runners: a client for the Runner Scale Set APIs.
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
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Serves the scale set emulator for clients in any language.
//!
//! ```sh
//! cargo run --features testing --bin scaleset-emulator -- --port 4100 --long-poll-ms 2000
//! ```
//!
//! Point a client at the printed `config_url`, authenticating with the token
//! given to `--pat` (default `ghp_emulator`). Drive the emulator through
//! `/_emulator`:
//!
//! | Request | Effect |
//! | --- | --- |
//! | `GET /_emulator/state` | current state |
//! | `POST /_emulator/jobs` `{"scaleSetId": 1001, "labels": ["linux"]}` | queue a job |
//! | `POST /_emulator/jobs/{id}/start` `{"runnerName": "r1"}` | start it on a runner |
//! | `POST /_emulator/jobs/{id}/complete` `{"result": "failed"}` | complete it |
//! | `POST /_emulator/faults` `{"endpoint": "getMessage", "response": {"kind": "status", "status": 503}, "times": 2}` | inject a fault |
//! | `DELETE /_emulator/faults` | clear faults |
//! | `POST /_emulator/expire/admin-tokens` | expire admin tokens |
//! | `POST /_emulator/expire/queue-token/{scaleSetId}` | expire a session's queue token |
//! | `POST /_emulator/expire/session/{scaleSetId}` | drop a session, as if it timed out |
//! | `POST /_emulator/reset` | clear everything |

#![expect(
    clippy::print_stdout,
    clippy::print_stderr,
    reason = "a command-line tool reports to its terminal"
)]

use std::net::{IpAddr, SocketAddr};
use std::process::ExitCode;
use std::time::Duration;

use scaleset::testing::Emulator;

const USAGE: &str = "\
usage: scaleset-emulator [options]

  --host <addr>                 address to bind (default 127.0.0.1)
  --port <port>                 port to bind (default 4100; 0 picks one)
  --pat <token>                 personal access token to accept (default ghp_emulator)
  --app-installation-id <id>    accept GitHub App JWTs for this installation
  --long-poll-ms <ms>           how long idle polls are held (default 50000)
  --auto-run-ms <ms>            start assigned jobs on idle runners and finish them after <ms>
  --admin-token-ttl-secs <s>    admin token lifetime (default 3600)
  --runner-group <name>         add a runner group (repeatable)
";

fn main() -> ExitCode {
    match parse(std::env::args().skip(1)) {
        Ok(Some((builder, addr))) => {
            let runtime = tokio::runtime::Builder::new_current_thread()
                .enable_all()
                .build()
                .expect("tokio runtime");
            runtime.block_on(async move {
                let emu = match builder.bind(addr).try_start().await {
                    Ok(emu) => emu,
                    Err(e) => {
                        eprintln!("error: cannot listen on {addr}: {e}");
                        return ExitCode::FAILURE;
                    }
                };
                println!(
                    "{}",
                    serde_json::json!({
                        "url": emu.uri(),
                        "config_url": emu.config_url(),
                        "control_url": format!("{}/_emulator", emu.uri()),
                    })
                );
                let _ = tokio::signal::ctrl_c().await;
                ExitCode::SUCCESS
            })
        }
        Ok(None) => {
            print!("{USAGE}");
            ExitCode::SUCCESS
        }
        Err(e) => {
            eprintln!("error: {e}\n\n{USAGE}");
            ExitCode::from(2)
        }
    }
}

fn parse(
    mut args: impl Iterator<Item = String>,
) -> Result<Option<(scaleset::testing::EmulatorBuilder, SocketAddr)>, String> {
    let mut builder = Emulator::builder();
    let mut host: IpAddr = [127, 0, 0, 1].into();
    let mut port = 4100u16;
    while let Some(flag) = args.next() {
        if flag == "-h" || flag == "--help" {
            return Ok(None);
        }
        let value = args.next().ok_or_else(|| format!("{flag} needs a value"))?;
        let number = |v: &str| {
            v.parse::<u64>()
                .map_err(|_| format!("{flag}: not a number: {v}"))
        };
        match flag.as_str() {
            "--host" => {
                host = value
                    .parse()
                    .map_err(|_| format!("invalid host: {value}"))?;
            }
            "--port" => {
                port = value
                    .parse()
                    .map_err(|_| format!("invalid port: {value}"))?;
            }
            "--pat" => builder = builder.pat(value),
            "--app-installation-id" => {
                builder = builder.github_app(
                    value
                        .parse()
                        .map_err(|_| format!("invalid installation ID: {value}"))?,
                );
            }
            "--long-poll-ms" => builder = builder.long_poll(Duration::from_millis(number(&value)?)),
            "--auto-run-ms" => {
                builder = builder.auto_run_jobs(Duration::from_millis(number(&value)?));
            }
            "--admin-token-ttl-secs" => {
                builder = builder.admin_token_ttl(Duration::from_secs(number(&value)?));
            }
            "--runner-group" => builder = builder.runner_group(value),
            other => return Err(format!("unknown option {other}")),
        }
    }
    Ok(Some((builder, SocketAddr::new(host, port))))
}