home.rs 79.2%

133 of 168 lines run, 22 of 61 functions · run #196 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>,
    /// `[runner.update]`: whether this runner takes updates (#85).
    #[serde(default)]
    pub update: Option<UpdateConfig>,
}

/// `[runner.update]` in flow.toml (docs/jetstream.md §8.2): the runner's
/// last word on updates, whatever the hub's policy says.
#[derive(Clone, Debug, Deserialize)]
pub struct UpdateConfig {
    /// `false` refuses every update, so a site can hold a machine back.
    #[serde(default = "yes")]
    pub allow: bool,
}

fn yes() -> bool {
    true
}

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;
            let mut f = crate::portable::private(std::fs::OpenOptions::new().write(true).create(true).truncate(true)).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		/// `[runner.update]`: whether this runner takes updates (#85).
91		#[serde(default)]
92		pub update: Option<UpdateConfig>,
93		}
94
95		/// `[runner.update]` in flow.toml (docs/jetstream.md §8.2): the runner's
96		/// last word on updates, whatever the hub's policy says.
97		#[derive(Clone, Debug, Deserialize)]
98		pub struct UpdateConfig {
99		/// `false` refuses every update, so a site can hold a machine back.
100		#[serde(default = "yes")]
101		pub allow: bool,
102		}
103
104	0×	fn yes() -> bool {
105	0×	true
106	0×	}
107
108		impl RunnerConfig {
109		/// The labels offered to the hub: the configured ones, and `egress`
110		/// when egress is on.
111	0×	pub fn offered_labels(&self) -> Vec<String> {
112	0×	let mut l = self.labels.clone();
113	0×	if self.egress && !l.iter().any(\|x\| x == flow_core::EGRESS_LABEL) {
114	0×	l.push(flow_core::EGRESS_LABEL.to_string());
115	0×	}
116	0×	l
117	0×	}
118		}
119
120		/// `[runner.swarm]` in flow.toml, or `[swarm]` in runner.toml.
121		#[derive(Clone, Debug, Deserialize)]
122		pub struct SwarmConfig {
123		/// Where peers reach this runner, e.g. `0.0.0.0:7401`.
124		pub listen: String,
125		/// The address peers are given (default: `listen`).
126		#[serde(default)]
127		pub advertise: Option<String>,
128		/// Peers are only ever in the same site.
129		#[serde(default)]
130		pub site: String,
131		/// The most this runner sends to peers, MiB a second (default 50).
132		#[serde(default)]
133		pub upload_mib_s: Option<u32>,
134		}
135
136		#[derive(Clone, Debug, Default, Deserialize)]
137		pub struct Config {
138		pub microvm: Option<MicrovmConfig>,
139		pub runner: Option<RunnerConfig>,
140		}
141
142		pub struct Home {
143		pub root: PathBuf,
144		pub config: Config,
145		/// Files already verified, by path, with the (len, mtime) they had then.
146		verified: Mutex<HashMap<PathBuf, (u64, std::time::SystemTime)>>,
147		}
148
149		impl Home {
150	18×	pub fn locate(explicit: Option<&Path>) -> Result<Home> {
151	18×	let root = match explicit {
152	18×	Some(p) => p.to_path_buf(),
153	0×	None => match std::env::var_os("FLOW_HOME") {
154	0×	Some(p) => PathBuf::from(p),
155	0×	None => PathBuf::from(std::env::var_os("HOME").context("HOME is not set")?).join(".local/share/flow"),
156		},
157		};
158	18×	let file = root.join("flow.toml");
159	18×	let mut config: Config = if file.is_file() {
160	0×	let text = std::fs::read_to_string(&file).with_context(\|\| format!("read {}", file.display()))?;
161	0×	toml::from_str(&text).with_context(\|\| format!("parse {}", file.display()))?
162		} else {
163	18×	Config::default()
164		};
165		// `flow runner register` writes the runner's hub and credential to
166		// runner.toml, which stands in for a [runner] section flow.toml lacks.
167	18×	let registered = root.join(RUNNER_TOML);
168	18×	if config.runner.is_none() && registered.is_file() {
169	9×	let text = std::fs::read_to_string(&registered).with_context(\|\| format!("read {}", registered.display()))?;
170	9×	config.runner = Some(toml::from_str(&text).with_context(\|\| format!("parse {}", registered.display()))?);
171	9×	}
172	54×	for d in ["cas", "work", "repos"] {
173	54×	std::fs::create_dir_all(root.join(d)).with_context(\|\| format!("create {}", root.join(d).display()))?;
174		}
175	18×	Ok(Home { root, config, verified: Mutex::new(HashMap::new()) })
176	18×	}
177
178	0×	pub fn resolve(&self, p: &Path) -> PathBuf {
179	0×	if p.is_absolute() {
180	0×	p.to_path_buf()
181		} else {
182	0×	self.root.join(p)
183		}
184	0×	}
185
186		/// Where a rootfs image with this hash lives.
187	35×	pub fn rootfs(&self, hash: &str) -> PathBuf {
188	35×	self.root.join("cas").join(format!("{hash}.ext4"))
189	35×	}
190
191		/// An image's manifest (`cas/<hash>.json`): what `flow rootfs import`
192		/// found out about it.
193	14×	pub fn image_manifest(&self, hash: &str) -> PathBuf {
194	14×	self.root.join("cas").join(format!("{hash}.json"))
195	14×	}
196
197		/// The architecture an image is for: as its manifest records, else
198		/// read from the image's own shell (spec §11.2) and recorded, so an
199		/// image fetched or imported without one is read once and a runner
200		/// declines what it cannot run instead of failing it. `None` when the
201		/// image is not here or names no architecture.
202	9×	pub fn image_arch(&self, hash: &str) -> Option<String> {
203	9×	let path = self.image_manifest(hash);
204	9×	let mut v: serde_json::Value =
205	9×	std::fs::read_to_string(&path).ok().and_then(\|t\| serde_json::from_str(&t).ok()).unwrap_or_else(\|\| serde_json::json!({}));
206	9×	if let Some(a) = v["arch"].as_str() {
207	3×	return Some(a.to_string());
208	6×	}
209	6×	let image = self.rootfs(hash);
210	6×	if v.get("arch_read_ms").is_some() \|\| !image.is_file() {
211	1×	return None;
212	5×	}
213	5×	let arch = jet::rootfs::arch_of_file(&image);
214	5×	let o = v.as_object_mut()?;
215	5×	if let Some(a) = arch {
216	1×	o.insert("arch".into(), a.into());
217	4×	}
218	5×	let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(\|d\| d.as_millis() as u64).unwrap_or(0);
219	5×	o.insert("arch_read_ms".into(), now.into());
220	5×	let tmp = path.with_extension("json.part");
221	5×	if std::fs::write(&tmp, v.to_string()).is_ok() {
222	5×	let _ = std::fs::rename(&tmp, &path);
223	5×	}
224	5×	arch.map(String::from)
225	9×	}
226
227		/// Every image with a known architecture (spec §11.2).
228	1×	pub fn image_archs(&self) -> std::collections::BTreeMap<String, String> {
229	1×	self.images().into_iter().filter_map(\|h\| self.image_arch(&h).map(\|a\| (h, a))).collect()
230	1×	}
231
232		/// The rootfs images this home holds: the hashes of `cas/*.ext4`.
233	10×	pub fn images(&self) -> Vec<String> {
234	10×	let Ok(dir) = std::fs::read_dir(self.root.join("cas")) else {
235	0×	return Vec::new();
236		};
237	10×	let mut out: Vec<String> = dir
238	10×	.filter_map(\|e\| {
239	5×	let name = e.ok()?.file_name().into_string().ok()?;
240	5×	let hash = name.strip_suffix(".ext4")?;
241	256×	(hash.len() == 64 && hash.chars().all(\|c\| c.is_ascii_hexdigit())).then(\|\| hash.to_string())
242	5×	})
243	10×	.collect();
244	10×	out.sort();
245	10×	out
246	10×	}
247
248		/// A pinned file, checked against its BLAKE3 before use (again only
249		/// when its size or modification time changed since).
250	4×	pub fn verified(&self, path: &Path, blake3_hex: &str) -> Result<PathBuf> {
251	4×	let meta = std::fs::metadata(path).with_context(\|\| format!("{} is missing", path.display()))?;
252	4×	let stamp = (meta.len(), meta.modified()?);
253	4×	if self.verified.lock().unwrap().get(path) == Some(&stamp) {
254	1×	return Ok(path.to_path_buf());
255	3×	}
256	3×	let mut got = hash_file(path)?;
257	3×	if got != blake3_hex {
258		// The read may have come from bad cached pages rather than the
259		// disk (oxygenflow#22: a RAM fault on Earth failed every job for
260		// hours while the file was intact): drop the file's pages and
261		// read it again from the disk before giving up.
262	1×	drop_cached(path);
263	1×	let again = hash_file(path)?;
264	1×	if again == blake3_hex {
265	0×	eprintln!(
266	0×	"warning: {} hashed {got} from the page cache but {again} from the disk: the cached copy was bad (check this machine's memory)",
267	0×	path.display()
268	0×	);
269	1×	}
270	1×	got = again;
271	2×	}
272	3×	if got != blake3_hex {
273	1×	bail!("{} has BLAKE3 {got}, but {blake3_hex} is pinned", path.display());
274	2×	}
275	2×	self.verified.lock().unwrap().insert(path.to_path_buf(), stamp);
276	2×	Ok(path.to_path_buf())
277	4×	}
278		}
279
280		/// Ask the kernel to forget a file's cached pages, so the next read comes
281		/// from the disk. Best effort: dirty pages and other platforms stay.
282	1×	fn drop_cached(path: &Path) {
283		#[cfg(target_os = "linux")]
284	1×	if let Ok(f) = std::fs::File::open(path) {
285		use std::os::fd::AsRawFd;
286		// SAFETY: a valid descriptor; the advice only affects caching.
287	1×	unsafe {
288	1×	libc::posix_fadvise(f.as_raw_fd(), 0, 0, libc::POSIX_FADV_DONTNEED);
289	1×	}
290	0×	}
291		#[cfg(not(target_os = "linux"))]
292		let _ = path;
293	1×	}
294
295	21×	pub fn hash_file(path: &Path) -> Result<String> {
296	21×	let mut h = blake3::Hasher::new();
297	21×	h.update_reader(std::fs::File::open(path).with_context(\|\| format!("open {}", path.display()))?)?;
298	21×	Ok(h.finalize().to_hex().to_string())
299	21×	}
300
301		/// The key a runner signs receipts with (Oxygen spec §14.6).
302		pub struct RunnerKey {
303		pub identity: oxy_core::identity::Identity,
304		pub secret: oxy_core::identity::SecretKey,
305		}
306
307		impl Home {
308		/// The runner's key, made on first use as `runner.key` (owner-only)
309		/// and `runner.identity`, named `name`.
310	4×	pub fn runner_key(&self, name: &str) -> Result<RunnerKey> {
311		use oxy_core::identity::{Identity, SecretKey};
312	4×	let key_path = self.root.join("runner.key");
313	4×	let id_path = self.root.join("runner.identity");
314	4×	if key_path.exists() {
315	2×	let (key, secret) = SecretKey::decode(&std::fs::read(&key_path)?).context("runner.key")?;
316	2×	let identity = Identity::decode(&std::fs::read(&id_path)?).context("runner.identity")?;
317	2×	if identity.hash() != key {
318	0×	bail!("runner.identity does not belong to runner.key");
319	2×	}
320	2×	return Ok(RunnerKey { identity, secret });
321	2×	}
322	2×	let secret = SecretKey::generate();
323	2×	let now = std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).map(\|d\| d.as_millis() as u64).unwrap_or(0);
324	2×	let identity = secret.identity(&format!("{name} (OxygenFlow runner)"), "", now);
325	2×	std::fs::write(&id_path, identity.encode())?;
326	2×	let tmp = self.root.join("runner.key.tmp");
327		{
328		use std::io::Write;
329	2×	let mut f = crate::portable::private(std::fs::OpenOptions::new().write(true).create(true).truncate(true)).open(&tmp)?;
330	2×	f.write_all(&secret.encode(&identity.hash()))?;
331	2×	f.sync_all()?;
332		}
333	2×	std::fs::rename(&tmp, &key_path)?;
334	2×	Ok(RunnerKey { identity, secret })
335	4×	}
336		}
337
338		#[cfg(test)]
339		mod tests {
340		use super::*;
341
342		#[test]
343	1×	fn the_runner_key_is_made_once_and_kept_private() {
344		use std::os::unix::fs::PermissionsExt;
345	1×	let dir = tempfile::tempdir().unwrap();
346	1×	let home = Home::locate(Some(dir.path())).unwrap();
347	1×	let a = home.runner_key("earth-1").unwrap();
348	1×	assert_eq!(a.identity.name, "earth-1 (OxygenFlow runner)");
349	1×	let mode = std::fs::metadata(dir.path().join("runner.key")).unwrap().permissions().mode();
350	1×	assert_eq!(mode & 0o777, 0o600);
351	1×	let b = home.runner_key("renamed").unwrap();
352	1×	assert_eq!(a.identity, b.identity, "the same key after a restart");
353	1×	let sig = b.secret.sign(oxy_core::identity::Domain::Attest, &b.identity.hash(), &oxy_core::hash::ObjectRef([1; 32]));
354	1×	oxy_core::identity::verify(&a.identity, &sig, oxy_core::identity::Domain::Attest, &oxy_core::hash::ObjectRef([1; 32])).unwrap();
355	1×	}
356		}

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

Keyboard