// docs/acceptance/0016-vm-image.md: a VM rented with a requester-chosen image (input image {url, sha256 of its image.json} // and marker) boots that image's kernel and rootfs: the contract is Held only after the requester matched the guest's // reported marker with the image.json's, /etc/swc-image in the guest is the marker, and the baked toolchain answers; then // the release and every record gone. Then the same image is rented a second time on the same kcp: if the target names the // winner's kcp, the FirecrackerVM's status.image.fetched of that second boot must be false (the bidder kept the image, it // did not fetch it again; the first boot's is recorded). `badsha`: the same with the sha256's first digit changed: no bidder takes the RFP // (it refuses before it bids), so the contract fails before any receipt, nothing is held and nothing is booted. `bigmarker`: the // image of 2026-11-14 whose image.json names a 272 byte marker (a marker has no length cap; the first bidders capped it at 256 and refused this image): its url, sha256 and marker // are fixed below (published content-addressed, so the fixture is that object); it is rented once like `run`'s first rent: Held, the guest's // reported marker equals the 272 byte one, the release, every record gone. use abi::{Event, Handle, Run, entries}; use serde_json::{Value, json}; use steps::{MIN, S, host, kube, sw}; const PROBE: &str = r#"echo "MARKER $(cat /etc/swc-image)"; . /opt/ci/env; echo "GO $(go version)"; echo "DOCKER $(command -v dockerd)"; echo "DENO $(deno --version | head -1)"; echo "CARGO $(cargo --version)""#; fn flipped(sha: &str) -> String { let mut c = sha.chars(); let first = if c.next() == Some('0') { '1' } else { '0' }; format!("{first}{}", c.as_str()) } /// The CI image whose image.json `marker` is 272 bytes (the first bidders refused it, a 256 byte cap): it must boot and report that marker. const BIGMARKER_URL: &str = "https://socialweb-computer-kcp.sfo3.digitaloceanspaces.com/vm-images/ci-toolchain/bb59b6472b7c62ff4ce70f77121b5e9481616d052246be1088dfcc83329e4507"; const BIGMARKER_SHA: &str = "bb59b6472b7c62ff4ce70f77121b5e9481616d052246be1088dfcc83329e4507"; const BIGMARKER_MARKER: &str = "ci-toolchain base=3edacb6a2537704a13f66f91880ce916eb0be299d514be523beb5e907e5de947 kcp=4be00b13b4cc402f1064eb8f0a1980ebe7cf470a toolchain=9cd5bdda394578116c71c8b986139631300fc37bd91ab41a8b1ab84cc59f0d26 pins=ccd19877f2ea5b024e6d91b25d0ca7e4aa06de30c8048c095875fe7af567447c"; fn image_of(args: &Value, bad: bool, big: bool) -> Option<(String, String, String)> { if big { return Some((BIGMARKER_URL.into(), BIGMARKER_SHA.into(), BIGMARKER_MARKER.into())); } let url = args["image"]["url"].as_str()?.to_string(); let sha = args["image"]["sha256"].as_str()?.to_string(); let marker = args["marker"].as_str().unwrap_or_default().to_string(); Some((url, if bad { flipped(&sha) } else { sha }, marker)) } fn run_with(run: Run, bad: bool, big: bool) -> Result { let args = &run.args; let mut s = S::new(run.state, args["now"].as_str().unwrap_or_default()); if let Some(h) = steps::market_event(&mut s, &run.event) { return Ok(h); } let round = s.st["round"].as_u64().unwrap_or(1); let rid = if round == 2 { "req2" } else { "req" }; let name = match (args["name"].as_str().ok_or("name")?, round) { (n, 2) => format!("{n}-b"), (n, _) => n.to_string(), }; let receipt = s.st["receipt"].as_str().unwrap_or_default().to_string(); let winner = receipt.trim_start_matches("at://").split('/').next().unwrap_or_default().to_string(); let cluster = args["bidders"].as_array().into_iter().flatten().find(|b| b["did"] == winner.as_str()).and_then(|b| b["cluster"].as_str()).map(String::from); let Some((url, sha, marker)) = image_of(args, bad, big) else { return Ok(s.unmet("the input names no image {url, sha256} (deploy/vm-images/ci-toolchain.json)")); }; let mut h = Handle::new(); match run.event { Event::Start => { s.set("held"); let a = json!(["--hold", "--cpus", "2", "--mem", "4G", "--expires-in", "1h", "--image", format!("{url}@{sha}")]); h = h.call(steps::host_sub("req", "request.start", json!({ "name": name, "args": a }))).timer("deadline", 80 * MIN); } Event::Timer { id } if id == "deadline" => return Ok(s.fail(format!("not done in 80 min (phase {})", s.phase()))), Event::Message { id, data, .. } if id == rid => { if s.st["receipt"].is_null() && data["receipt"].is_string() { s.st["receipt"] = data["receipt"].clone(); } match data["msg"].as_str().unwrap_or_default() { "requester_guest_image" if !bad => { s.reading(&format!("guest_image_{round}"), json!({ "marker": data["marker"], "expected": data["expected"], "ok": data["ok"] })); if data["ok"] != true || data["marker"] != marker.as_str() { return Ok(s.fail(format!("the guest reported a marker the requester did not accept: {data}"))); } s.flag("imageOk"); } "contract" if bad && data["phase"] == "Failed" => { if !s.st["receipt"].is_null() || s.has("held") { return Ok(s.fail(format!("a VM was rented with a wrong image sha256: {data}"))); } s.reading("refused", json!({ "message": data["message"] })); s.reading("refused_s", s.t()); if !data["message"].as_str().unwrap_or_default().contains("no bidder can serve this request") { return Ok(s.fail(format!("the contract failed, but not as every bidder's refusal of the image: {}", data["message"]))); } return Ok(s.pass()); } "contract" if bad && data["phase"] == "Held" => return Ok(s.fail("the contract was Held with a wrong image sha256")), "exited" if bad && !s.has("held") => return Ok(s.fail(format!("run request exited without failing the contract: {data}"))), "contract" if !bad && data["phase"] == "Failed" => return Ok(s.fail(format!("the contract failed before Held: {}", data["message"]))), "contract" if !bad && data["phase"] == "Held" => s.flag("held"), "exited" if !bad && !s.has("releasing") => return Ok(s.fail(format!("run request exited before the release: {data}"))), _ => {} } if !bad && s.is("held") && s.has("held") && s.has("imageOk") && s.st["receipt"].is_string() { s.reading(&format!("held_{round}_s"), s.t()); s.set("probe"); h = h.call(host("probe", "request.ssh", json!({ "name": name, "exec": PROBE }))); } } Event::Result { id, result, .. } => { let o = match steps::out(&s, &id, result.output()) { Ok(o) => o, Err(f) => return Ok(f), }; match id.as_str() { "probe" => { let text = o["output"].as_str().unwrap_or_default(); let line = |k: &str| text.lines().find_map(|l| l.strip_prefix(k)).map(|v| v.trim().to_string()).unwrap_or_default(); let guest = line("MARKER "); s.reading(&format!("guest_marker_{round}"), guest.clone()); s.reading("toolchain", json!({ "go": line("GO "), "dockerd": line("DOCKER "), "deno": line("DENO "), "cargo": line("CARGO ") })); if guest != marker { return Ok(s.fail(format!("/etc/swc-image in the guest is {guest:?}, not {marker:?}"))); } if !line("GO ").contains("go1.") || !line("CARGO ").starts_with("cargo ") { return Ok(s.fail(format!("the baked toolchain does not answer: {text}"))); } match cluster { Some(c) => { s.set("fetched"); h = h.call(kube("vms", "list", &c, json!({ "apiVersion": "socialweb.computer/v1alpha1", "kind": "ComputeVM" }))); } None => return Ok(s.unmet("the target names no kcp for the winner: whether the image was fetched is not checked")), } } "vms" => { let mine: Vec<&Value> = o["items"].as_array().into_iter().flatten().filter(|v| v["spec"]["contract"]["receipt"]["uri"] == receipt.as_str()).collect(); let [vm] = mine.as_slice() else { return Ok(s.fail(format!("{} ComputeVMs of this run's receipt on the winner", mine.len()))); }; let vm_name = vm["metadata"]["name"].as_str().unwrap_or_default().to_string(); h = h.call(kube("fc", "get", cluster.as_deref().unwrap_or_default(), sw("FirecrackerVM", &vm_name))); } "fc" => { let fetched = o["status"]["image"]["fetched"] == true; s.reading(&format!("image_fetched_{round}"), json!({ "fetched": fetched, "image": o["status"]["image"]["sha256"] })); if round == 2 && fetched { return Ok(s.fail(format!("the second rent of the same image on the same bidder fetched it again: {}", o["status"]["image"]))); } s.set("release"); s.flag("releasing"); h = h.call(host("release", "request.release", json!({ "name": name }))); } "release" => { s.reading(&format!("release_{round}_s"), o["seconds"].clone()); h = h.call(host("records", "request.records", json!({ "name": name }))); } "records" => { s.reading(&format!("records_checked_{round}"), o["uris"].as_array().map_or(0, Vec::len)); h = h.call(host("gone", "assert.recordsGone", json!({ "uris": o["uris"] }))); } "gone" => { if o["left"].as_array().is_none_or(|l| !l.is_empty()) { return Ok(s.fail(format!("records left: {} {}", o["left"], o["errors"]))); } if round == 1 && !bad && !big { s.st["round"] = json!(2); s.st["receipt"] = Value::Null; s.st["f"] = json!({}); s.set("held"); let a = json!(["--hold", "--cpus", "2", "--mem", "4G", "--expires-in", "1h", "--image", format!("{url}@{sha}")]); h = h.call(steps::host_sub("req2", "request.start", json!({ "name": format!("{}-b", args["name"].as_str().unwrap_or_default()), "args": a, "bidderDids": [winner] }))); return Ok(s.keep(h)); } return Ok(s.pass()); } _ => {} } } Event::Closed { id, error } if id == rid && !s.has("releasing") && !bad => return Ok(s.fail(format!("req closed: {}", error.unwrap_or_default()))), _ => {} } Ok(s.keep(h)) } fn run_0016(run: Run) -> Result { run_with(run, false, false) } fn badsha_0016(run: Run) -> Result { run_with(run, true, false) } fn bigmarker_0016(run: Run) -> Result { run_with(run, false, true) } entries! { run => run_0016, badsha => badsha_0016, bigmarker => bigmarker_0016 }