Skip to content
Sign up

flagon-io/g1t

public
00

Where people and agents ship software together. The open-source git platform for the whole job: issues, agents, checks and deploys to the edge.

g1t.sh
gitagentscloudflarerustforgemcp
183 linesCodeBlameRaw
1//! What `g1t-runner register` keeps: where g1t is, who this runner is, its
2//! credential, and how it runs work. One JSON file in the runner's folder,
3//! readable by its owner only.
4
5use std::path::{Path, PathBuf};
6
7use anyhow::{Context, Result};
8use serde::{Deserialize, Serialize};
9
10#[derive(Clone, Debug, Serialize, Deserialize)]
11pub struct Config {
12 /// The site, as given to `--url`: `https://g1t.sh`.
13 pub url: String,
14 /// The API the runner calls: `https://api.g1t.sh`.
15 pub api: String,
16 /// The runner's id and name.
17 pub runner: String,
18 pub name: String,
19 /// Its credential (`g1tr_…`). Rotated by g1t every day.
20 pub credential: String,
21 pub workspace: String,
22 #[serde(default)]
23 pub repo: Option<String>,
24 #[serde(default)]
25 pub group: Option<String>,
26 pub labels: Vec<String>,
27 /// Runs one job, then removes itself.
28 #[serde(default)]
29 pub ephemeral: bool,
30 /// Where jobs keep their files when they run on this machine directly.
31 pub work_dir: PathBuf,
32 /// Runs work in Docker containers (the default), or directly.
33 #[serde(default = "yes")]
34 pub docker: bool,
35 /// The image workflow jobs run in when they name no `container:`.
36 #[serde(default)]
37 pub image: Option<String>,
38 /// The image agent work runs in: git, Node and the agent's CLI.
39 #[serde(default)]
40 pub agent_image: Option<String>,
41 /// A Linux build of `g1t-runner` to run inside containers, instead of
42 /// this binary (on Linux) or the release's (elsewhere).
43 #[serde(default)]
44 pub harness: Option<PathBuf>,
45 /// Checks for new versions and updates itself.
46 #[serde(default = "yes")]
47 pub auto_update: bool,
48 /// Each job container's memory limit (`--memory`): `8g`. Three
49 /// quarters of the machine's (or the runner container's) memory if
50 /// left out.
51 #[serde(default)]
52 pub memory: Option<String>,
53 /// Each job container's CPUs (`--cpus`): `2`, `1.5`. Every CPU if left out.
54 #[serde(default)]
55 pub cpus: Option<String>,
56 /// The most processes in a job container (`--pids-limit`). 4096 if left out.
57 #[serde(default)]
58 pub pids_limit: Option<u32>,
59 /// With nested-container isolation, a job that uses Docker gets an
60 /// engine of its own. Off: jobs have no Docker.
61 #[serde(default = "yes")]
62 pub job_docker: bool,
63 /// The image a job's own engine runs: `docker:28-dind` if left out.
64 #[serde(default)]
65 pub job_docker_image: Option<String>,
66 /// Runs jobs native to this OS, each in a throwaway VM of its own
67 /// (`--native`, native.rs): Windows Sandbox on Windows.
68 #[serde(default)]
69 pub native: bool,
70}
71
72fn yes() -> bool {
73 true
74}
75
76/// The runner's folder: `--dir`, `G1T_RUNNER_DIR`, else `.g1t-runner` in
77/// the home folder.
78pub fn folder(given: Option<&str>) -> PathBuf {
79 if let Some(dir) = given.filter(|d| !d.is_empty()) {
80 return PathBuf::from(dir);
81 }
82 if let Some(dir) = std::env::var_os("G1T_RUNNER_DIR").filter(|d| !d.is_empty()) {
83 return PathBuf::from(dir);
84 }
85 let home = std::env::var_os(if cfg!(windows) { "USERPROFILE" } else { "HOME" })
86 .map(PathBuf::from)
87 .unwrap_or_else(|| PathBuf::from("."));
88 home.join(".g1t-runner")
89}
90
91pub fn path(folder: &Path) -> PathBuf {
92 folder.join("config.json")
93}
94
95pub fn load(folder: &Path) -> Result<Config> {
96 let file = path(folder);
97 let text = std::fs::read_to_string(&file)
98 .with_context(|| format!("this runner is not registered ({} not found): run `g1t-runner register` first", file.display()))?;
99 serde_json::from_str(&text).with_context(|| format!("{} does not read", file.display()))
100}
101
102/// Writes the configuration so only its owner can read it, in a folder
103/// only its owner can read (private.rs), through a temporary file, so a
104/// crash never leaves half a credential.
105pub fn save(folder: &Path, config: &Config) -> Result<()> {
106 super::private::folder(folder, "--dir")?;
107 super::private::write_private(&path(folder), serde_json::to_string_pretty(config)?.as_bytes())
108}
109
110pub fn forget(folder: &Path) {
111 let _ = std::fs::remove_file(path(folder));
112}
113
114/// The API for a site: `https://g1t.sh` calls `https://api.g1t.sh`.
115pub fn api_for(url: &str) -> String {
116 let url = url.trim_end_matches('/');
117 match url.split_once("://") {
118 Some((scheme, host)) if !host.starts_with("api.") && !host.starts_with("localhost") && !host.starts_with("127.") => {
119 format!("{scheme}://api.{host}")
120 }
121 _ => url.to_owned(),
122 }
123}
124
125#[cfg(test)]
126mod tests {
127 use super::*;
128
129 #[test]
130 fn the_api_is_found_from_the_site() {
131 assert_eq!(api_for("https://g1t.sh"), "https://api.g1t.sh");
132 assert_eq!(api_for("https://g1t.sh/"), "https://api.g1t.sh");
133 assert_eq!(api_for("https://api.g1t.sh"), "https://api.g1t.sh");
134 assert_eq!(api_for("https://git.example.com"), "https://api.git.example.com");
135 assert_eq!(api_for("http://localhost:8787"), "http://localhost:8787");
136 }
137
138 #[test]
139 fn an_older_configuration_still_reads() {
140 let old = r#"{"url":"https://g1t.sh","api":"https://api.g1t.sh","runner":"rnr_1","name":"a","credential":"g1tr_x",
141 "workspace":"acme","labels":["self-hosted"],"work_dir":"/tmp/w"}"#;
142 let config: Config = serde_json::from_str(old).unwrap();
143 assert!(config.docker && config.job_docker && config.auto_update);
144 assert_eq!(config.memory, None);
145 }
146
147 #[test]
148 fn a_configuration_survives_a_round_trip() {
149 let dir = std::env::temp_dir().join(format!("g1t-runner-config-{}", std::process::id()));
150 let config = Config {
151 url: "https://g1t.sh".into(),
152 api: "https://api.g1t.sh".into(),
153 runner: "rnr_1".into(),
154 name: "build-01".into(),
155 credential: "g1tr_x".into(),
156 workspace: "acme".into(),
157 repo: None,
158 group: Some("Default".into()),
159 labels: vec!["self-hosted".into(), "linux".into()],
160 ephemeral: false,
161 work_dir: dir.join("work"),
162 docker: true,
163 image: None,
164 agent_image: None,
165 harness: None,
166 auto_update: true,
167 memory: Some("4g".into()),
168 cpus: None,
169 pids_limit: None,
170 job_docker: true,
171 job_docker_image: None,
172 native: false,
173 };
174 save(&dir, &config).unwrap();
175 let back = load(&dir).unwrap();
176 assert_eq!(back.runner, "rnr_1");
177 assert_eq!(back.labels, config.labels);
178 assert_eq!(back.memory.as_deref(), Some("4g"));
179 forget(&dir);
180 assert!(load(&dir).is_err());
181 let _ = std::fs::remove_dir_all(&dir);
182 }
183}