Files
woiken-sandboxes/src/kernel.rs
T
niklas 56762648e3 fix(#6): connect/read timeouts on every HTTP agent
No ureq call had a timeout, so a silent registry hung pull forever. One
oci::agent() builder (30 s connect + per-read) now backs registry agents,
local ones included, and the kernel downloads.
2026-10-22 19:54:09 +02:00

86 lines
3.9 KiB
Rust

//! Guest kernel: Kata Containers release kernel, downloaded and sha256-verified.
use crate::oci;
use anyhow::{Context, Result, anyhow, bail};
use serde_json::{Value, json};
use sha2::{Digest, Sha256};
use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
const KATA_REPO: &str = "kata-containers/kata-containers";
/// Where Kata's release tarball keeps the guest kernel (VM-ready arm64 Image, all virtio built in).
const KATA_KERNEL: &str = "opt/kata/share/kata-containers/vmlinux.container";
pub fn installed_kernel(h: &Path) -> Option<String> {
let v: Value = serde_json::from_slice(&fs::read(h.join("kernel/source.json")).ok()?).ok()?;
v["version"].as_str().map(String::from)
}
/// Guest kernel from the latest (or pinned) Kata Containers release. Never re-downloads implicitly:
/// runs use whatever is installed; `wsbx kernel --update` moves to a newer release.
pub fn kernel(h: &Path, update: bool, version: Option<String>) -> Result<PathBuf> {
let k = h.join("kernel/vmlinux");
let installed = installed_kernel(h);
let pin = version.or_else(|| std::env::var("WSBX_KATA_VERSION").ok());
if k.exists() && !update && (pin.is_none() || pin == installed) {
return Ok(k);
}
if let Some(v) = &pin
&& (v.is_empty() || !v.chars().all(|c| c.is_ascii_alphanumeric() || "._-".contains(c)))
{
bail!("invalid Kata version {v:?}");
}
let api = match &pin {
Some(v) => format!("https://api.github.com/repos/{KATA_REPO}/releases/tags/{v}"),
None => format!("https://api.github.com/repos/{KATA_REPO}/releases/latest"),
};
let agent = oci::agent().build();
let rel: Value = serde_json::from_reader(agent.get(&api).call().with_context(|| format!("GET {api}"))?.into_reader())?;
let tag = rel["tag_name"].as_str().ok_or_else(|| anyhow!("no tag in {api}"))?;
if k.exists() && installed.as_deref() == Some(tag) {
eprintln!("wsbx: kernel already at Kata {tag}");
return Ok(k);
}
let asset = rel["assets"]
.as_array()
.into_iter()
.flatten()
.find(|a| a["name"].as_str().is_some_and(|n| n.starts_with("kata-static-") && n.ends_with("-arm64.tar.zst")))
.ok_or_else(|| anyhow!("Kata {tag} has no kata-static arm64 asset"))?;
let url = asset["browser_download_url"].as_str().ok_or_else(|| anyhow!("asset without url"))?;
eprintln!(
"wsbx: fetching kernel from Kata Containers {tag} ({} MB, streamed; only the kernel is kept)",
asset["size"].as_u64().unwrap_or(0) / 1_000_000
);
let tmp = h.join("kernel.tmp");
let _ = fs::remove_dir_all(&tmp);
fs::create_dir_all(&tmp)?;
// Stream download -> sha256 + bsdtar (zstd); nothing but the kernel touches the disk.
let mut tar = Command::new("tar")
.args(["-x", "--zstd", "-f", "-", "-C"])
.arg(&tmp)
.arg(format!("{}*", KATA_KERNEL.trim_end_matches(".container")))
.stdin(Stdio::piped())
.spawn()?;
let mut w = oci::HashWriter(tar.stdin.take().unwrap(), Sha256::new());
std::io::copy(&mut agent.get(url).call()?.into_reader(), &mut w)?;
let oci::HashWriter(stdin, hasher) = w;
drop(stdin);
if !tar.wait()?.success() {
bail!("kernel extraction failed");
}
let got = format!("sha256:{}", hex::encode(hasher.finalize()));
match asset["digest"].as_str() {
Some(want) if want != got => bail!("kernel download checksum mismatch: want {want}, got {got}"),
Some(_) => {}
None => eprintln!("wsbx: warning: release publishes no digest; download not verified"),
}
let src = fs::canonicalize(tmp.join(KATA_KERNEL))?;
fs::create_dir_all(k.parent().unwrap())?;
fs::rename(src, &k)?;
let _ = fs::remove_file(h.join("kernel/SOURCE")); // pre-source.json format
fs::write(h.join("kernel/source.json"), serde_json::to_vec_pretty(&json!({"version": tag, "url": url, "sha256": got}))?)?;
fs::remove_dir_all(&tmp)?;
Ok(k)
}