home.rs 80.6%

133 of 165 lines run, 22 of 59 functions · run #181 on main · run missed

//! `$FLOW_HOME` (default `~/.local/share/flow`): the pinned parts of each
//! isolation tier, rootfs images by hash, scratch space and the runner's
//! configuration, all described by `flow.toml`.
//!
//! ```toml
//! [microvm]
//! firecracker = { path = "bin/firecracker", blake3 = "…" }
//! kernel = { path = "kernel/vmlinux", blake3 = "…" }
//! init = { path = "bin/flow-init", blake3 = "…" }
//!
//! [runner]                       # only for `flow runner`
//! hub = "https://hub.example:7343"
//! token = "…"                    # a runner token from the hub's [flow] runner_tokens
//! ca = "/path/to/hub-ca.pem"     # when the hub's certificate is self-signed
//! name = "earth-1"
//! ```
//!
//! A runner signs its receipts with a composite key kept beside `flow.toml`
//! (`runner.key`, `runner.identity`), made on first start.

use anyhow::{bail, Context, Result};
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Mutex;

#[derive(Clone, Debug, Deserialize)]
pub struct Pinned {
    pub path: PathBuf,
    pub blake3: String,
}

#[derive(Clone, Debug, Deserialize)]
pub struct MicrovmConfig {
    pub firecracker: Pinned,
    pub kernel: Pinned,
    pub init: Pinned,
}

/// Where `flow runner register` keeps the runner's hub and credential.
pub const RUNNER_TOML: &str = "runner.toml";

#[derive(Clone, Debug, Deserialize)]
pub struct RunnerConfig {
    pub hub: String,
    pub token: String,
    pub ca: Option<PathBuf>,
    pub name: Option<String>,
    /// Jobs run at once (default 1).
    #[serde(default)]
    pub max_jobs: Option<usize>,
    /// Labels the runner offers, e.g. `gpu`, `big-disk`.
    #[serde(default)]
    pub labels: Vec<String>,
    /// Memory (MiB) and vCPUs the jobs running at once may use together.
    #[serde(default)]
    pub memory_mib: Option<u32>,
    #[serde(default)]
    pub cpus: Option<u32>,
    /// Sharing images with other runners (docs/jetstream.md §8.1): absent,
    /// the runner neither serves nor asks peers.
    #[serde(default)]
    pub swarm: Option<SwarmConfig>,
    /// The build cache's size limit in GiB (#28; default 64).
    #[serde(default)]
    pub cache_gb: Option<u64>,
    /// The share of its disk, in percent, a kept build cache may fill
    /// (oxygenflow#72; default 60): over it, the files the job did not use
    /// are pruned, oldest first, and a cache still over it is not kept.
    #[serde(default)]
    pub cache_prune_percent: Option<u8>,
    /// Let microVM jobs reach the hosts their sandbox allows, through this
    /// runner (oxygenflow#55); off unless set. The runner then offers the
    /// `egress` label, which such jobs need.
    #[serde(default)]
    pub egress: bool,
    /// Sign each job's receipt with a fresh key the hub certifies for that
    /// job, just before signing (keyless, oxygenhub#241), rather than with
    /// the runner's own key; off unless set. When the hub cannot certify,
    /// the runner's key signs, and the job's log says why.
    #[serde(default)]
    pub keyless: bool,
    /// Serve this runner's metrics at this address, e.g. `127.0.0.1:9464`
    /// (oxygenflow#35); off unless set.
    #[serde(default)]
    pub metrics: Option<String>,
    /// A bearer token a scrape of the metrics must send.
    #[serde(default)]
    pub metrics_token: Option<String>,
}

impl RunnerConfig {
    /// The labels offered to the hub: the configured ones, and `egress`
    /// when egress is on.
    pub fn offered_labels(&self) -> Vec<String> {
        let mut l = self.labels.clone();
        if self.egress && !l.iter().any(|x| x == flow_core::EGRESS_LABEL) {
            l.push(flow_core::EGRESS_LABEL.to_string());
        }
        l
    }
}

/// `[runner.swarm]` in flow.toml, or `[swarm]` in runner.toml.
#[derive(Clone, Debug, Deserialize)]
pub struct SwarmConfig {
    /// Where peers reach this runner, e.g. `0.0.0.0:7401`.
    pub listen: String,
    /// The address peers are given (default: `listen`).
    #[serde(default)]
    pub advertise: Option<String>,
    /// Peers are only ever in the same site.
    #[serde(default)]
    pub site: String,
    /// The most this runner sends to peers, MiB a second (default 50).
    #[serde(default)]
    pub upload_mib_s: Option<u32>,
}

#[derive(Clone, Debug, Default, Deserialize)]
pub struct Config {
    pub microvm: Option<MicrovmConfig>,
    pub runner: Option<RunnerConfig>,
}

pub struct Home {
    pub root: PathBuf,
    pub config: Config,
    /// Files already verified, by path, with the (len, mtime) they had then.
    verified: Mutex<HashMap<PathBuf, (u64, std::time::SystemTime)>>,
}

impl Home {
    pub fn locate(explicit: Option<&Path>) -> Result<Home> {
        let root = match explicit {
            Some(p) => p.to_path_buf(),
            None => match std::env::var_os("FLOW_HOME") {
                Some(p) => PathBuf::from(p),
                None => PathBuf::from(std::env::var_os("HOME").context("HOME is not set")?).join(".local/share/flow"),
            },
        };
        let file = root.join("flow.toml");
        let mut config: Config = if file.is_file() {
            let text = std::fs::read_to_string(&file).with_context(|| format!("read {}", file.display()))?;
            toml::from_str(&text).with_context(|| format!("parse {}", file.display()))?
        } else {
            Config::default()
        };
        // `flow runner register` writes the runner's hub and credential to
        // runner.toml, which stands in for a [runner] section flow.toml lacks.
        let registered = root.join(RUNNER_TOML);
        if config.runner.is_none() && registered.is_file() {
            let text = std::fs::read_to_string(&registered).with_context(|| format!("read {}", registered.display()))?;
            config.runner = Some(toml::from_str(&text).with_context(|| format!("parse {}", registered.display()))?);
        }
        for d in ["cas", "work", "repos"] {
            std::fs::create_dir_all(root.join(d)).with_context(|| format!("create {}", root.join(d).display()))?;
        }
        Ok(Home { root, config, verified: Mutex::new(HashMap::new()) })
    }

    pub fn resolve(&self, p: &Path) -> PathBuf {
        if p.is_absolute() {
            p.to_path_buf()
        } else {
            self.root.join(p)
        }
    }

    /// Where a rootfs image with this hash lives.
    pub fn rootfs(&self, hash: &str) -> PathBuf {
        self.root.join("cas").join(format!("{hash}.ext4"))
    }

    /// An image's manifest (`cas/<hash>.json`): what `flow rootfs import`
    /// found out about it.
    pub fn image_manifest(&self, hash: &str) -> PathBuf {
        self.root.join("cas").join(format!("{hash}.json"))
    }

    /// The architecture an image is for: as its manifest records, else
    /// read from the image's own shell (spec §11.2) and recorded, so an
    /// image fetched or imported without one is read once and a runner
    /// declines what it cannot run instead of failing it. `None` when the
    /// image is not here or names no architecture.
    pub fn image_arch(&self, hash: &str) -> Option<String> {
        let path = self.image_manifest(hash);
        let mut v: serde_json::Value =
            std::fs::read_to_string(&path).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or_else(|| serde_json::json!({}));
        if let Some(a) = v["arch"].as_str() {
            return Some(a.to_string());
        }
        let image = self.rootfs(hash);
        if v.get("arch_read_ms").is_some() || !image.is_file() {
            return None;
        }
        let arch = jet::rootfs::arch_of_file(&image);
        let o = v.as_object_mut()?;
        if let Some(a) = arch {
            o.insert("arch".into(), a.into());
        }
        let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);
        o.insert("arch_read_ms".into(), now.into());
        let tmp = path.with_extension("json.part");
        if std::fs::write(&tmp, v.to_string()).is_ok() {
            let _ = std::fs::rename(&tmp, &path);
        }
        arch.map(String::from)
    }

    /// Every image with a known architecture (spec §11.2).
    pub fn image_archs(&self) -> std::collections::BTreeMap<String, String> {
        self.images().into_iter().filter_map(|h| self.image_arch(&h).map(|a| (h, a))).collect()
    }

    /// The rootfs images this home holds: the hashes of `cas/*.ext4`.
    pub fn images(&self) -> Vec<String> {
        let Ok(dir) = std::fs::read_dir(self.root.join("cas")) else {
            return Vec::new();
        };
        let mut out: Vec<String> = dir
            .filter_map(|e| {
                let name = e.ok()?.file_name().into_string().ok()?;
                let hash = name.strip_suffix(".ext4")?;
                (hash.len() == 64 && hash.chars().all(|c| c.is_ascii_hexdigit())).then(|| hash.to_string())
            })
            .collect();
        out.sort();
        out
    }

    /// A pinned file, checked against its BLAKE3 before use (again only
    /// when its size or modification time changed since).
    pub fn verified(&self, path: &Path, blake3_hex: &str) -> Result<PathBuf> {
        let meta = std::fs::metadata(path).with_context(|| format!("{} is missing", path.display()))?;
        let stamp = (meta.len(), meta.modified()?);
        if self.verified.lock().unwrap().get(path) == Some(&stamp) {
            return Ok(path.to_path_buf());
        }
        let mut got = hash_file(path)?;
        if got != blake3_hex {
            // The read may have come from bad cached pages rather than the
            // disk (oxygenflow#22: a RAM fault on Earth failed every job for
            // hours while the file was intact): drop the file's pages and
            // read it again from the disk before giving up.
            drop_cached(path);
            let again = hash_file(path)?;
            if again == blake3_hex {
                eprintln!(
                    "warning: {} hashed {got} from the page cache but {again} from the disk: the cached copy was bad (check this machine's memory)",
                    path.display()
                );
            }
            got = again;
        }
        if got != blake3_hex {
            bail!("{} has BLAKE3 {got}, but {blake3_hex} is pinned", path.display());
        }
        self.verified.lock().unwrap().insert(path.to_path_buf(), stamp);
        Ok(path.to_path_buf())
    }
}

/// Ask the kernel to forget a file's cached pages, so the next read comes
/// from the disk. Best effort: dirty pages and other platforms stay.
fn drop_cached(path: &Path) {
    #[cfg(target_os = "linux")]
    if let Ok(f) = std::fs::File::open(path) {
        use std::os::fd::AsRawFd;
        // SAFETY: a valid descriptor; the advice only affects caching.
        unsafe {
            libc::posix_fadvise(f.as_raw_fd(), 0, 0, libc::POSIX_FADV_DONTNEED);
        }
    }
    #[cfg(not(target_os = "linux"))]
    let _ = path;
}

pub fn hash_file(path: &Path) -> Result<String> {
    let mut h = blake3::Hasher::new();
    h.update_reader(std::fs::File::open(path).with_context(|| format!("open {}", path.display()))?)?;
    Ok(h.finalize().to_hex().to_string())
}

/// The key a runner signs receipts with (Oxygen spec §14.6).
pub struct RunnerKey {
    pub identity: oxy_core::identity::Identity,
    pub secret: oxy_core::identity::SecretKey,
}

impl Home {
    /// The runner's key, made on first use as `runner.key` (owner-only)
    /// and `runner.identity`, named `name`.
    pub fn runner_key(&self, name: &str) -> Result<RunnerKey> {
        use oxy_core::identity::{Identity, SecretKey};
        let key_path = self.root.join("runner.key");
        let id_path = self.root.join("runner.identity");
        if key_path.exists() {
            let (key, secret) = SecretKey::decode(&std::fs::read(&key_path)?).context("runner.key")?;
            let identity = Identity::decode(&std::fs::read(&id_path)?).context("runner.identity")?;
            if identity.hash() != key {
                bail!("runner.identity does not belong to runner.key");
            }
            return Ok(RunnerKey { identity, secret });
        }
        let secret = SecretKey::generate();
        let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0);
        let identity = secret.identity(&format!("{name} (OxygenFlow runner)"), "", now);
        std::fs::write(&id_path, identity.encode())?;
        let tmp = self.root.join("runner.key.tmp");
        {
            use std::io::Write;
            use std::os::unix::fs::OpenOptionsExt;
            let mut f = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(&tmp)?;
            f.write_all(&secret.encode(&identity.hash()))?;
            f.sync_all()?;
        }
        std::fs::rename(&tmp, &key_path)?;
        Ok(RunnerKey { identity, secret })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn the_runner_key_is_made_once_and_kept_private() {
        use std::os::unix::fs::PermissionsExt;
        let dir = tempfile::tempdir().unwrap();
        let home = Home::locate(Some(dir.path())).unwrap();
        let a = home.runner_key("earth-1").unwrap();
        assert_eq!(a.identity.name, "earth-1 (OxygenFlow runner)");
        let mode = std::fs::metadata(dir.path().join("runner.key")).unwrap().permissions().mode();
        assert_eq!(mode & 0o777, 0o600);
        let b = home.runner_key("renamed").unwrap();
        assert_eq!(a.identity, b.identity, "the same key after a restart");
        let sig = b.secret.sign(oxy_core::identity::Domain::Attest, &b.identity.hash(), &oxy_core::hash::ObjectRef([1; 32]));
        oxy_core::identity::verify(&a.identity, &sig, oxy_core::identity::Domain::Attest, &oxy_core::hash::ObjectRef([1; 32])).unwrap();
    }
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! `$FLOW_HOME` (default `~/.local/share/flow`): the pinned parts of each
2		//! isolation tier, rootfs images by hash, scratch space and the runner's
3		//! configuration, all described by `flow.toml`.
4		//!
5		//! ```toml
6		//! [microvm]
7		//! firecracker = { path = "bin/firecracker", blake3 = "…" }
8		//! kernel = { path = "kernel/vmlinux", blake3 = "…" }
9		//! init = { path = "bin/flow-init", blake3 = "…" }
10		//!
11		//! [runner] # only for `flow runner`
12		//! hub = "https://hub.example:7343"
13		//! token = "…" # a runner token from the hub's [flow] runner_tokens
14		//! ca = "/path/to/hub-ca.pem" # when the hub's certificate is self-signed
15		//! name = "earth-1"
16		//! ```
17		//!
18		//! A runner signs its receipts with a composite key kept beside `flow.toml`
19		//! (`runner.key`, `runner.identity`), made on first start.
20
21		use anyhow::{bail, Context, Result};
22		use serde::Deserialize;
23		use std::collections::HashMap;
24		use std::path::{Path, PathBuf};
25		use std::sync::Mutex;
26
27		#[derive(Clone, Debug, Deserialize)]
28		pub struct Pinned {
29		pub path: PathBuf,
30		pub blake3: String,
31		}
32
33		#[derive(Clone, Debug, Deserialize)]
34		pub struct MicrovmConfig {
35		pub firecracker: Pinned,
36		pub kernel: Pinned,
37		pub init: Pinned,
38		}
39
40		/// Where `flow runner register` keeps the runner's hub and credential.
41		pub const RUNNER_TOML: &str = "runner.toml";
42
43		#[derive(Clone, Debug, Deserialize)]
44		pub struct RunnerConfig {
45		pub hub: String,
46		pub token: String,
47		pub ca: Option<PathBuf>,
48		pub name: Option<String>,
49		/// Jobs run at once (default 1).
50		#[serde(default)]
51		pub max_jobs: Option<usize>,
52		/// Labels the runner offers, e.g. `gpu`, `big-disk`.
53		#[serde(default)]
54		pub labels: Vec<String>,
55		/// Memory (MiB) and vCPUs the jobs running at once may use together.
56		#[serde(default)]
57		pub memory_mib: Option<u32>,
58		#[serde(default)]
59		pub cpus: Option<u32>,
60		/// Sharing images with other runners (docs/jetstream.md §8.1): absent,
61		/// the runner neither serves nor asks peers.
62		#[serde(default)]
63		pub swarm: Option<SwarmConfig>,
64		/// The build cache's size limit in GiB (#28; default 64).
65		#[serde(default)]
66		pub cache_gb: Option<u64>,
67		/// The share of its disk, in percent, a kept build cache may fill
68		/// (oxygenflow#72; default 60): over it, the files the job did not use
69		/// are pruned, oldest first, and a cache still over it is not kept.
70		#[serde(default)]
71		pub cache_prune_percent: Option<u8>,
72		/// Let microVM jobs reach the hosts their sandbox allows, through this
73		/// runner (oxygenflow#55); off unless set. The runner then offers the
74		/// `egress` label, which such jobs need.
75		#[serde(default)]
76		pub egress: bool,
77		/// Sign each job's receipt with a fresh key the hub certifies for that
78		/// job, just before signing (keyless, oxygenhub#241), rather than with
79		/// the runner's own key; off unless set. When the hub cannot certify,
80		/// the runner's key signs, and the job's log says why.
81		#[serde(default)]
82		pub keyless: bool,
83		/// Serve this runner's metrics at this address, e.g. `127.0.0.1:9464`
84		/// (oxygenflow#35); off unless set.
85		#[serde(default)]
86		pub metrics: Option<String>,
87		/// A bearer token a scrape of the metrics must send.
88		#[serde(default)]
89		pub metrics_token: Option<String>,
90		}
91
92		impl RunnerConfig {
93		/// The labels offered to the hub: the configured ones, and `egress`
94		/// when egress is on.
95	0×	pub fn offered_labels(&self) -> Vec<String> {
96	0×	let mut l = self.labels.clone();
97	0×	if self.egress && !l.iter().any(\|x\| x == flow_core::EGRESS_LABEL) {
98	0×	l.push(flow_core::EGRESS_LABEL.to_string());
99	0×	}
100	0×	l
101	0×	}
102		}
103
104		/// `[runner.swarm]` in flow.toml, or `[swarm]` in runner.toml.
105		#[derive(Clone, Debug, Deserialize)]
106		pub struct SwarmConfig {
107		/// Where peers reach this runner, e.g. `0.0.0.0:7401`.
108		pub listen: String,
109		/// The address peers are given (default: `listen`).
110		#[serde(default)]
111		pub advertise: Option<String>,
112		/// Peers are only ever in the same site.
113		#[serde(default)]
114		pub site: String,
115		/// The most this runner sends to peers, MiB a second (default 50).
116		#[serde(default)]
117		pub upload_mib_s: Option<u32>,
118		}
119
120		#[derive(Clone, Debug, Default, Deserialize)]
121		pub struct Config {
122		pub microvm: Option<MicrovmConfig>,
123		pub runner: Option<RunnerConfig>,
124		}
125
126		pub struct Home {
127		pub root: PathBuf,
128		pub config: Config,
129		/// Files already verified, by path, with the (len, mtime) they had then.
130		verified: Mutex<HashMap<PathBuf, (u64, std::time::SystemTime)>>,
131		}
132
133		impl Home {
134	18×	pub fn locate(explicit: Option<&Path>) -> Result<Home> {
135	18×	let root = match explicit {
136	18×	Some(p) => p.to_path_buf(),
137	0×	None => match std::env::var_os("FLOW_HOME") {
138	0×	Some(p) => PathBuf::from(p),
139	0×	None => PathBuf::from(std::env::var_os("HOME").context("HOME is not set")?).join(".local/share/flow"),
140		},
141		};
142	18×	let file = root.join("flow.toml");
143	18×	let mut config: Config = if file.is_file() {
144	0×	let text = std::fs::read_to_string(&file).with_context(\|\| format!("read {}", file.display()))?;
145	0×	toml::from_str(&text).with_context(\|\| format!("parse {}", file.display()))?
146		} else {
147	18×	Config::default()
148		};
149		// `flow runner register` writes the runner's hub and credential to
150		// runner.toml, which stands in for a [runner] section flow.toml lacks.
151	18×	let registered = root.join(RUNNER_TOML);
152	18×	if config.runner.is_none() && registered.is_file() {
153	9×	let text = std::fs::read_to_string(&registered).with_context(\|\| format!("read {}", registered.display()))?;
154	9×	config.runner = Some(toml::from_str(&text).with_context(\|\| format!("parse {}", registered.display()))?);
155	9×	}
156	54×	for d in ["cas", "work", "repos"] {
157	54×	std::fs::create_dir_all(root.join(d)).with_context(\|\| format!("create {}", root.join(d).display()))?;
158		}
159	18×	Ok(Home { root, config, verified: Mutex::new(HashMap::new()) })
160	18×	}
161
162	0×	pub fn resolve(&self, p: &Path) -> PathBuf {
163	0×	if p.is_absolute() {
164	0×	p.to_path_buf()
165		} else {
166	0×	self.root.join(p)
167		}
168	0×	}
169
170		/// Where a rootfs image with this hash lives.
171	35×	pub fn rootfs(&self, hash: &str) -> PathBuf {
172	35×	self.root.join("cas").join(format!("{hash}.ext4"))
173	35×	}
174
175		/// An image's manifest (`cas/<hash>.json`): what `flow rootfs import`
176		/// found out about it.
177	14×	pub fn image_manifest(&self, hash: &str) -> PathBuf {
178	14×	self.root.join("cas").join(format!("{hash}.json"))
179	14×	}
180
181		/// The architecture an image is for: as its manifest records, else
182		/// read from the image's own shell (spec §11.2) and recorded, so an
183		/// image fetched or imported without one is read once and a runner
184		/// declines what it cannot run instead of failing it. `None` when the
185		/// image is not here or names no architecture.
186	9×	pub fn image_arch(&self, hash: &str) -> Option<String> {
187	9×	let path = self.image_manifest(hash);
188	9×	let mut v: serde_json::Value =
189	9×	std::fs::read_to_string(&path).ok().and_then(\|t\| serde_json::from_str(&t).ok()).unwrap_or_else(\|\| serde_json::json!({}));
190	9×	if let Some(a) = v["arch"].as_str() {
191	3×	return Some(a.to_string());
192	6×	}
193	6×	let image = self.rootfs(hash);
194	6×	if v.get("arch_read_ms").is_some() \|\| !image.is_file() {
195	1×	return None;
196	5×	}
197	5×	let arch = jet::rootfs::arch_of_file(&image);
198	5×	let o = v.as_object_mut()?;
199	5×	if let Some(a) = arch {
200	1×	o.insert("arch".into(), a.into());
201	4×	}
202	5×	let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(\|d\| d.as_millis() as u64).unwrap_or(0);
203	5×	o.insert("arch_read_ms".into(), now.into());
204	5×	let tmp = path.with_extension("json.part");
205	5×	if std::fs::write(&tmp, v.to_string()).is_ok() {
206	5×	let _ = std::fs::rename(&tmp, &path);
207	5×	}
208	5×	arch.map(String::from)
209	9×	}
210
211		/// Every image with a known architecture (spec §11.2).
212	1×	pub fn image_archs(&self) -> std::collections::BTreeMap<String, String> {
213	1×	self.images().into_iter().filter_map(\|h\| self.image_arch(&h).map(\|a\| (h, a))).collect()
214	1×	}
215
216		/// The rootfs images this home holds: the hashes of `cas/*.ext4`.
217	10×	pub fn images(&self) -> Vec<String> {
218	10×	let Ok(dir) = std::fs::read_dir(self.root.join("cas")) else {
219	0×	return Vec::new();
220		};
221	10×	let mut out: Vec<String> = dir
222	10×	.filter_map(\|e\| {
223	5×	let name = e.ok()?.file_name().into_string().ok()?;
224	5×	let hash = name.strip_suffix(".ext4")?;
225	256×	(hash.len() == 64 && hash.chars().all(\|c\| c.is_ascii_hexdigit())).then(\|\| hash.to_string())
226	5×	})
227	10×	.collect();
228	10×	out.sort();
229	10×	out
230	10×	}
231
232		/// A pinned file, checked against its BLAKE3 before use (again only
233		/// when its size or modification time changed since).
234	4×	pub fn verified(&self, path: &Path, blake3_hex: &str) -> Result<PathBuf> {
235	4×	let meta = std::fs::metadata(path).with_context(\|\| format!("{} is missing", path.display()))?;
236	4×	let stamp = (meta.len(), meta.modified()?);
237	4×	if self.verified.lock().unwrap().get(path) == Some(&stamp) {
238	1×	return Ok(path.to_path_buf());
239	3×	}
240	3×	let mut got = hash_file(path)?;
241	3×	if got != blake3_hex {
242		// The read may have come from bad cached pages rather than the
243		// disk (oxygenflow#22: a RAM fault on Earth failed every job for
244		// hours while the file was intact): drop the file's pages and
245		// read it again from the disk before giving up.
246	1×	drop_cached(path);
247	1×	let again = hash_file(path)?;
248	1×	if again == blake3_hex {
249	0×	eprintln!(
250	0×	"warning: {} hashed {got} from the page cache but {again} from the disk: the cached copy was bad (check this machine's memory)",
251	0×	path.display()
252	0×	);
253	1×	}
254	1×	got = again;
255	2×	}
256	3×	if got != blake3_hex {
257	1×	bail!("{} has BLAKE3 {got}, but {blake3_hex} is pinned", path.display());
258	2×	}
259	2×	self.verified.lock().unwrap().insert(path.to_path_buf(), stamp);
260	2×	Ok(path.to_path_buf())
261	4×	}
262		}
263
264		/// Ask the kernel to forget a file's cached pages, so the next read comes
265		/// from the disk. Best effort: dirty pages and other platforms stay.
266	1×	fn drop_cached(path: &Path) {
267		#[cfg(target_os = "linux")]
268	1×	if let Ok(f) = std::fs::File::open(path) {
269		use std::os::fd::AsRawFd;
270		// SAFETY: a valid descriptor; the advice only affects caching.
271	1×	unsafe {
272	1×	libc::posix_fadvise(f.as_raw_fd(), 0, 0, libc::POSIX_FADV_DONTNEED);
273	1×	}
274	0×	}
275		#[cfg(not(target_os = "linux"))]
276		let _ = path;
277	1×	}
278
279	21×	pub fn hash_file(path: &Path) -> Result<String> {
280	21×	let mut h = blake3::Hasher::new();
281	21×	h.update_reader(std::fs::File::open(path).with_context(\|\| format!("open {}", path.display()))?)?;
282	21×	Ok(h.finalize().to_hex().to_string())
283	21×	}
284
285		/// The key a runner signs receipts with (Oxygen spec §14.6).
286		pub struct RunnerKey {
287		pub identity: oxy_core::identity::Identity,
288		pub secret: oxy_core::identity::SecretKey,
289		}
290
291		impl Home {
292		/// The runner's key, made on first use as `runner.key` (owner-only)
293		/// and `runner.identity`, named `name`.
294	4×	pub fn runner_key(&self, name: &str) -> Result<RunnerKey> {
295		use oxy_core::identity::{Identity, SecretKey};
296	4×	let key_path = self.root.join("runner.key");
297	4×	let id_path = self.root.join("runner.identity");
298	4×	if key_path.exists() {
299	2×	let (key, secret) = SecretKey::decode(&std::fs::read(&key_path)?).context("runner.key")?;
300	2×	let identity = Identity::decode(&std::fs::read(&id_path)?).context("runner.identity")?;
301	2×	if identity.hash() != key {
302	0×	bail!("runner.identity does not belong to runner.key");
303	2×	}
304	2×	return Ok(RunnerKey { identity, secret });
305	2×	}
306	2×	let secret = SecretKey::generate();
307	2×	let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(\|d\| d.as_millis() as u64).unwrap_or(0);
308	2×	let identity = secret.identity(&format!("{name} (OxygenFlow runner)"), "", now);
309	2×	std::fs::write(&id_path, identity.encode())?;
310	2×	let tmp = self.root.join("runner.key.tmp");
311		{
312		use std::io::Write;
313		use std::os::unix::fs::OpenOptionsExt;
314	2×	let mut f = std::fs::OpenOptions::new().write(true).create(true).truncate(true).mode(0o600).open(&tmp)?;
315	2×	f.write_all(&secret.encode(&identity.hash()))?;
316	2×	f.sync_all()?;
317		}
318	2×	std::fs::rename(&tmp, &key_path)?;
319	2×	Ok(RunnerKey { identity, secret })
320	4×	}
321		}
322
323		#[cfg(test)]
324		mod tests {
325		use super::*;
326
327		#[test]
328	1×	fn the_runner_key_is_made_once_and_kept_private() {
329		use std::os::unix::fs::PermissionsExt;
330	1×	let dir = tempfile::tempdir().unwrap();
331	1×	let home = Home::locate(Some(dir.path())).unwrap();
332	1×	let a = home.runner_key("earth-1").unwrap();
333	1×	assert_eq!(a.identity.name, "earth-1 (OxygenFlow runner)");
334	1×	let mode = std::fs::metadata(dir.path().join("runner.key")).unwrap().permissions().mode();
335	1×	assert_eq!(mode & 0o777, 0o600);
336	1×	let b = home.runner_key("renamed").unwrap();
337	1×	assert_eq!(a.identity, b.identity, "the same key after a restart");
338	1×	let sig = b.secret.sign(oxy_core::identity::Domain::Attest, &b.identity.hash(), &oxy_core::hash::ObjectRef([1; 32]));
339	1×	oxy_core::identity::verify(&a.identity, &sig, oxy_core::identity::Domain::Attest, &oxy_core::hash::ObjectRef([1; 32])).unwrap();
340	1×	}
341		}

Coverage / crates/flow/src/home.rs 80.6%

Keyboard