use std::path::{Path, PathBuf};
use std::sync::Arc;
use super::lima::{
check_publish, drift, gib_flag, map_mounts, owned_name, refuse_gpu, resolve_binary, run_cli, s,
vm_cpus, vm_disk_gib, writable_home_mount, Host,
};
use super::lxc::SandboxSize;
use super::{docker, Allocation, Budget, HostResources, Limits, Probe, Runtime, RuntimeKind};
use super::{StartSpec, State, GIB};
pub const PROFILE: &str = "zakuro";
pub const NOT_INSTALLED: &str = "colima is not installed";
pub const MIN_VERSION: (u32, u32, u32) = (0, 8, 0);
pub trait ColimaCli: Send + Sync {
fn run(&self, argv: &[String]) -> Result<String, String>;
fn config(&self, profile: &str) -> Result<Option<String>, String>;
}
pub struct ColimaShell {
bin: String,
}
impl ColimaShell {
pub fn new() -> Self {
Self {
bin: resolve_binary(
"colima",
"ZAKURO_COLIMA",
&|k| std::env::var(k).ok(),
&|p| p.is_file(),
),
}
}
pub fn binary() -> String {
Self::new().bin
}
fn config_path(profile: &str) -> Option<PathBuf> {
let home = std::env::var_os("HOME").map(PathBuf::from);
let mut roots: Vec<PathBuf> = Vec::new();
if let Some(c) = std::env::var_os("COLIMA_HOME") {
roots.push(c.into());
}
if let Some(h) = &home {
roots.push(h.join(".colima"));
}
if let Some(x) = std::env::var_os("XDG_CONFIG_HOME") {
roots.push(Path::new(&x).join("colima"));
}
if let Some(h) = &home {
roots.push(h.join(".config").join("colima"));
}
let rel = Path::new(profile).join("colima.yaml");
roots.iter().map(|r| r.join(&rel)).find(|p| p.is_file())
}
}
impl Default for ColimaShell {
fn default() -> Self {
Self::new()
}
}
impl ColimaCli for ColimaShell {
fn run(&self, argv: &[String]) -> Result<String, String> {
run_cli(&self.bin, "colima", NOT_INSTALLED, argv, None)
}
fn config(&self, profile: &str) -> Result<Option<String>, String> {
match Self::config_path(profile) {
None => Ok(None),
Some(p) => std::fs::read_to_string(&p)
.map(Some)
.map_err(|e| format!("cannot read {}: {e}", p.display())),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Info {
pub name: String,
pub status: String,
pub cpus: u32,
pub memory_bytes: u64,
pub disk_bytes: u64,
}
pub fn parse_list(out: &str) -> Vec<Info> {
out.lines()
.filter_map(|l| serde_json::from_str::<serde_json::Value>(l.trim()).ok())
.filter_map(|v| {
Some(Info {
name: v["name"].as_str()?.to_string(),
status: v["status"].as_str().unwrap_or("").to_string(),
cpus: v["cpus"].as_u64().unwrap_or(0) as u32,
memory_bytes: v["memory"].as_u64().unwrap_or(0),
disk_bytes: v["disk"].as_u64().unwrap_or(0),
})
})
.collect()
}
pub fn parse_mounts(yaml: &str) -> Option<Vec<(String, bool)>> {
let mut lines = yaml.lines();
let first = lines
.by_ref()
.find(|l| l.starts_with("mounts:"))?
.trim_start_matches("mounts:")
.trim();
if first.starts_with('[') {
return (first != "[]").then(Vec::new);
}
let unq = |v: &str| v.trim().trim_matches(|c| c == '"' || c == '\'').to_string();
let mut out: Vec<(String, bool)> = Vec::new();
for l in lines {
if !l.is_empty() && !l.starts_with(' ') && !l.starts_with('-') && !l.starts_with('#') {
break;
}
let t = l.trim().trim_start_matches('-').trim();
if let Some(loc) = t.strip_prefix("location:") {
out.push((unq(loc), false));
} else if let Some(w) = t.strip_prefix("writable:") {
if let Some(last) = out.last_mut() {
last.1 = unq(w) == "true";
}
}
}
(!out.is_empty()).then_some(out)
}
pub fn start_argv(
profile: &str,
size: &SandboxSize,
host: &Host,
grow_disk: bool,
fresh: bool,
) -> Vec<String> {
let mut a = s(&["colima", "start", "-p", profile]);
if fresh {
a.extend(s(&["--runtime", "docker", "--vm-type", "vz"]));
if host.apple_silicon {
a.push("--vz-rosetta".into());
}
a.extend(s(&["--activate=false", "--ssh-config=false"]));
if let Some(w) = &host.work_dir {
a.push("--mount".into());
a.push(format!("{}:w", w.display()));
} else {
a.extend(s(&["--mount", "none"]));
}
}
a.extend(s(&["-c", &vm_cpus(&size.limits).to_string()]));
a.extend(s(&["-m", &gib_flag(size.limits.memory_bytes)]));
if fresh || grow_disk {
a.extend(s(&["-d", &vm_disk_gib(size).to_string()]));
}
a
}
pub fn parse_version(out: &str) -> Option<(u32, u32, u32)> {
super::lima::parse_version(out.lines().next()?)
}
pub fn egress_script() -> String {
"set -e; \
iptables -N ZAKURO-EGRESS 2>/dev/null || true; iptables -F ZAKURO-EGRESS; \
iptables -A ZAKURO-EGRESS -m conntrack --ctstate ESTABLISHED,RELATED -j RETURN; \
iptables -A ZAKURO-EGRESS -o docker0 -j RETURN; iptables -A ZAKURO-EGRESS -o br-+ -j RETURN; \
for ns in $(awk '/^nameserver/{print $2}' /etc/resolv.conf /run/systemd/resolve/resolv.conf 2>/dev/null | grep -E '^[0-9.]+$' | sort -u); do \
iptables -A ZAKURO-EGRESS -d $ns -p udp --dport 53 -j RETURN; \
iptables -A ZAKURO-EGRESS -d $ns -p tcp --dport 53 -j RETURN; \
done; \
for r in 10.0.0.0/8 172.16.0.0/12 192.168.0.0/16 169.254.0.0/16 100.64.0.0/10; do \
iptables -A ZAKURO-EGRESS -d $r -j REJECT; \
done; \
for i in docker0 br-+; do \
iptables -C DOCKER-USER -i $i -j ZAKURO-EGRESS 2>/dev/null || iptables -I DOCKER-USER 1 -i $i -j ZAKURO-EGRESS; \
done; \
iptables -N ZAKURO-IN 2>/dev/null || true; iptables -F ZAKURO-IN; \
for ns in $(awk '/^nameserver/{print $2}' /etc/resolv.conf /run/systemd/resolve/resolv.conf 2>/dev/null | grep -E '^[0-9.]+$' | sort -u); do \
iptables -A ZAKURO-IN -d $ns -p udp --dport 53 -j RETURN; \
iptables -A ZAKURO-IN -d $ns -p tcp --dport 53 -j RETURN; \
done; \
iptables -A ZAKURO-IN -d 172.16.0.0/12 -j RETURN; \
iptables -A ZAKURO-IN -m addrtype --dst-type LOCAL -j REJECT; \
for i in docker0 br-+; do \
iptables -C INPUT -i $i -j ZAKURO-IN 2>/dev/null || iptables -I INPUT 1 -i $i -j ZAKURO-IN; \
done"
.to_string()
}
static ENSURE_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
#[derive(Clone)]
pub struct ColimaRuntime {
cli: Arc<dyn ColimaCli>,
profile: String,
size: Result<SandboxSize, String>,
host: Host,
mkdir: fn(&std::path::Path) -> std::io::Result<()>,
macos_version: Option<(u32, u32)>,
}
impl ColimaRuntime {
pub fn new(
cli: Arc<dyn ColimaCli>,
profile: &str,
size: Result<SandboxSize, String>,
host: Host,
) -> Self {
Self {
cli,
profile: profile.to_string(),
size,
host,
mkdir: |p| std::fs::create_dir_all(p),
macos_version: None,
}
}
#[cfg(test)]
pub(crate) fn with_mkdir(mut self, f: fn(&std::path::Path) -> std::io::Result<()>) -> Self {
self.mkdir = f;
self
}
pub fn from_env(cli: Arc<dyn ColimaCli>, get: &dyn Fn(&str) -> Option<String>) -> Self {
let profile = get("ZAKURO_COLIMA_PROFILE")
.map(|v| v.trim().to_string())
.filter(|v| !v.is_empty())
.unwrap_or_else(|| PROFILE.to_string());
let size = Budget::from_env(get)
.and_then(|b| SandboxSize::from_budget(&b, &HostResources::detect()));
Self::new(cli, &profile, size, Host::detect())
}
pub fn shell() -> Self {
let mut rt = Self::from_env(Arc::new(ColimaShell::new()), &|k| std::env::var(k).ok());
rt.size = super::machine_size();
rt.macos_version = super::provision::macos_version();
rt
}
pub fn profile(&self) -> &str {
&self.profile
}
fn colima(&self, rest: &[&str]) -> Result<String, String> {
let mut argv = vec!["colima".to_string()];
argv.extend(rest.iter().map(|a| a.to_string()));
self.cli.run(&argv)
}
pub fn in_vm(&self, docker_argv: &[String]) -> Vec<String> {
let mut a = s(&["colima", "ssh", "-p", &self.profile, "--", "docker"]);
let rest = match docker_argv.first().map(String::as_str) {
Some("docker") => &docker_argv[1..],
_ => docker_argv,
};
a.extend(rest.iter().cloned());
a
}
pub fn exec_sh(&self, script: &str) -> Result<String, String> {
self.colima(&["ssh", "-p", &self.profile, "--", "sh", "-c", script])
}
fn docker(&self, docker_argv: &[String]) -> Result<String, String> {
self.cli.run(&self.in_vm(docker_argv))
}
pub fn info(&self) -> Result<Option<Info>, String> {
let out = self.colima(&["list", "--json"])?;
Ok(parse_list(&out)
.into_iter()
.find(|i| i.name == self.profile))
}
fn running(i: &Info) -> bool {
i.status.eq_ignore_ascii_case("Running")
}
fn adoption_problem(&self) -> Result<Option<String>, String> {
let Some(yaml) = self.cli.config(&self.profile)? else {
return Ok(None);
};
let p = &self.profile;
let Some(mounts) = parse_mounts(&yaml) else {
return Ok(Some(format!(
"colima profile {p} has Colima's default mounts, which include the owner's home; \
refusing to adopt it (`colima delete -p {p}` and zc recreates it with only \
the zakuro work directory)"
)));
};
Ok(self.host.home.as_deref().and_then(|h| {
writable_home_mount(&mounts, h).map(|m| {
format!(
"colima profile {p} mounts {m} writable, which gives the VM the owner's \
home; refusing to adopt it (`colima delete -p {p}` and zc recreates it)"
)
})
}))
}
pub fn resize_pending(&self) -> Result<bool, String> {
let size = self.size.clone()?;
Ok(self
.info()?
.map(|i| drift(i.cpus, i.memory_bytes, i.disk_bytes, &size).any())
.unwrap_or(false))
}
pub fn ensure(&self) -> Result<(), String> {
let _g = ENSURE_LOCK.lock().unwrap_or_else(|p| p.into_inner());
owned_name(&self.profile, "Colima profile")?;
if !self.host.macos {
return Err("the colima backend runs on macOS only".into());
}
if let Some(why) = super::provision::too_old(self.macos_version) {
return Err(why);
}
let size = self.size.clone()?;
let p = self.profile.as_str();
match self.info()? {
None => {
if let Some(problem) = self.adoption_problem()? {
return Err(problem);
}
if let Some(w) = &self.host.work_dir {
(self.mkdir)(w).map_err(|e| format!("cannot create {}: {e}", w.display()))?;
}
self.cli
.run(&start_argv(p, &size, &self.host, false, true))
.map_err(|e| format!("colima start -p {p} failed: {e}"))?;
}
Some(info) => {
if let Some(problem) = self.adoption_problem()? {
return Err(problem);
}
let d = drift(info.cpus, info.memory_bytes, info.disk_bytes, &size);
if Self::running(&info) {
if d.any() && self.is_idle()? {
self.colima(&["stop", "-p", p])?;
self.cli
.run(&start_argv(p, &size, &self.host, d.disk_grows, false))
.map_err(|e| format!("colima start -p {p} failed: {e}"))?;
}
} else if info.status.eq_ignore_ascii_case("Stopped") {
self.cli
.run(&start_argv(p, &size, &self.host, d.disk_grows, false))
.map_err(|e| format!("colima start -p {p} failed: {e}"))?;
} else {
return Err(format!(
"colima profile {p} is {} (not Running or Stopped); \
`colima delete -p {p}` and zc recreates it",
info.status
));
}
}
}
let mut fw = s(&["colima", "ssh", "-p", p, "--", "sudo", "sh", "-c"]);
fw.push(egress_script());
self.cli
.run(&fw)
.map_err(|e| format!("applying the guest firewall in {p} failed: {e}"))?;
self.docker(&s(&["version"]))
.map_err(|e| format!("docker is not ready in colima profile {p}: {e}"))?;
Ok(())
}
fn is_idle(&self) -> Result<bool, String> {
Ok(self.docker(&s(&["ps", "-q"]))?.trim().is_empty())
}
}
impl Runtime for ColimaRuntime {
fn kind(&self) -> RuntimeKind {
RuntimeKind::Colima
}
fn probe(&self) -> Probe {
let no = |detail: String| Probe {
kind: RuntimeKind::Colima,
available: false,
detail,
};
if !self.host.macos {
return no("macOS only".into());
}
if let Some(why) = super::provision::too_old(self.macos_version) {
return no(why);
}
if let Err(e) = owned_name(&self.profile, "Colima profile") {
return no(e);
}
let out = match self.colima(&["version"]) {
Ok(v) => v,
Err(e) if e.starts_with(NOT_INSTALLED) => {
return no(format!(
"{NOT_INSTALLED} (brew install colima, or set ZAKURO_COLIMA)"
))
}
Err(e) => return no(e.lines().next().unwrap_or("colima version failed").into()),
};
let Some(v) = parse_version(&out) else {
return no(format!("cannot read the colima version from {out:?}"));
};
if v < MIN_VERSION {
return no(format!(
"colima {}.{}.{} is too old: zc needs {}.{}.{} or newer (brew upgrade colima)",
v.0, v.1, v.2, MIN_VERSION.0, MIN_VERSION.1, MIN_VERSION.2
));
}
let vm = match self.info() {
Err(e) => return no(e.lines().next().unwrap_or("colima list failed").into()),
Ok(None) => "not created yet (created at the first start)".to_string(),
Ok(Some(i)) => {
match self.adoption_problem() {
Ok(Some(p)) => return no(p),
Ok(None) => {}
Err(e) => return no(e),
}
format!(
"{} ({} cpu, {:.1} GiB memory)",
i.status.to_lowercase(),
i.cpus,
i.memory_bytes as f64 / GIB
)
}
};
Probe {
kind: RuntimeKind::Colima,
available: true,
detail: format!(
"colima {}.{}.{}, vz profile {} {vm}",
v.0, v.1, v.2, self.profile
),
}
}
fn verify_image(&self, image: &str, expected_digest: Option<&str>) -> Result<(), String> {
let out = self
.docker(&s(&[
"docker",
"image",
"inspect",
"--format",
"{{.Id}}|{{json .RepoDigests}}",
image,
]))
.map_err(|e| {
format!(
"image {image} is not in colima profile {}: {e}",
self.profile
)
})?;
let Some(want) = expected_digest else {
return Ok(());
};
let want = want.rsplit('@').next().unwrap_or(want);
if out.contains(want) {
Ok(())
} else {
Err(format!(
"image {image} does not match the expected digest {want}"
))
}
}
fn start(&self, spec: &StartSpec) -> Result<String, String> {
refuse_gpu("colima", spec)?;
check_publish("colima", &spec.publish)?;
let mounts = map_mounts(self.host.work_dir.as_deref(), &spec.mounts)?;
self.ensure()?;
let size = self.size.clone()?;
let mut inner = spec.clone();
inner.mounts = mounts;
inner.limits = Limits {
cpu_millis: inner.limits.cpu_millis.min(size.limits.cpu_millis),
memory_bytes: inner.limits.memory_bytes.min(size.limits.memory_bytes),
gpus: super::Gpus::None,
};
if spec.create_network {
if let Some(net) = &spec.network {
let _ = self.docker(&s(&["docker", "network", "create", net]));
}
}
let mut run = vec!["docker".to_string()];
run.extend(docker::run_argv(&inner));
self.docker(&run)
}
fn exec(&self, name: &str, argv: &[String], detach: bool) -> Result<String, String> {
let mut full = s(&["docker", "exec"]);
if detach {
full.push("-d".into());
}
full.push(name.to_string());
full.extend(argv.iter().cloned());
self.docker(&full)
}
fn stop(&self, name: &str) -> Result<(), String> {
match self.info()? {
Some(i) if Self::running(&i) => {}
_ => return Ok(()),
}
match self.docker(&crate::up::docker_rm_argv(name)) {
Ok(_) => Ok(()),
Err(e) if e.contains("No such container") || e.contains("no such container") => Ok(()),
Err(e) => Err(e),
}
}
fn limits(&self, name: &str) -> Result<Limits, String> {
super::lxc::parse_cgroup_limits(&self.docker(&s(&[
"docker",
"exec",
name,
"sh",
"-c",
"cat /sys/fs/cgroup/cpu.max /sys/fs/cgroup/memory.max; \
ls -d /dev/nvidia[0-9]* 2>/dev/null | wc -l",
]))?)
}
fn health(&self, name: &str) -> Result<State, String> {
let out = self.docker(&crate::up::docker_state_argv(name))?;
crate::up::parse_container_state(&out)
.ok_or_else(|| format!("unexpected docker inspect output: {out:?}"))
}
fn allocations(&self) -> Result<Vec<Allocation>, String> {
match self.info()? {
Some(i) if Self::running(&i) => {}
_ => return Ok(Vec::new()),
}
let mut argv = vec!["docker".to_string()];
argv.extend(docker::allocations_args());
Ok(docker::parse_allocations(&self.docker(&argv)?))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::sandbox::Gpus;
use std::sync::Mutex;
const MIB: u64 = 1024 * 1024;
#[derive(Default)]
struct Rec {
calls: Mutex<Vec<String>>,
answer: Mutex<Vec<(&'static str, Result<String, String>)>>,
config: Mutex<Option<String>>,
}
impl Rec {
fn on(&self, needle: &'static str, a: Result<&str, &str>) {
self.answer
.lock()
.unwrap()
.push((needle, a.map(String::from).map_err(String::from)));
}
fn calls(&self) -> Vec<String> {
self.calls.lock().unwrap().clone()
}
fn with_config(&self, yaml: &str) {
*self.config.lock().unwrap() = Some(yaml.to_string());
}
}
impl ColimaCli for Rec {
fn run(&self, argv: &[String]) -> Result<String, String> {
let j = argv.join(" ");
self.calls.lock().unwrap().push(j.clone());
for (needle, a) in self.answer.lock().unwrap().iter() {
if j.contains(needle) {
return a.clone();
}
}
Ok(String::new())
}
fn config(&self, _profile: &str) -> Result<Option<String>, String> {
Ok(self.config.lock().unwrap().clone())
}
}
fn size() -> SandboxSize {
SandboxSize {
limits: Limits::new(1.5, 2.0, Gpus::None),
disk_bytes: 10 * 1024 * MIB,
}
}
fn host() -> Host {
Host {
macos: true,
apple_silicon: true,
home: Some("/Users/jo".into()),
work_dir: Some("/Users/jo/.zakuro".into()),
}
}
fn rt(rec: &Arc<Rec>) -> ColimaRuntime {
ColimaRuntime::new(rec.clone(), PROFILE, Ok(size()), host()).with_mkdir(|_| Ok(()))
}
fn spec() -> StartSpec {
StartSpec {
name: "zc-share-w0".into(),
image: "img".into(),
network: None,
create_network: false,
labels: vec![],
mounts: vec![("/Users/jo/.zakuro/work".into(), "/work".into())],
publish: vec![],
env: vec![],
cmd: vec![],
limits: Limits::new(0.5, 1.0, Gpus::None),
remove_on_exit: true,
hardened: false,
}
}
fn list_line(status: &str, cpus: u32, mem_gib: u64, disk_gib: u64) -> String {
format!(
r#"{{"name":"zakuro","status":"{status}","arch":"aarch64","cpus":{cpus},"memory":{},"disk":{},"runtime":"docker"}}"#,
mem_gib * 1024 * MIB,
disk_gib * 1024 * MIB
)
}
const GOOD_YAML: &str = "cpu: 2\nmounts:\n - location: /Users/jo/.zakuro\n mountPoint: /Users/jo/.zakuro\n writable: true\ndiskImage: \"\"\n";
#[test]
fn a_new_profile_is_started_with_the_budget_and_only_the_work_dir() {
assert_eq!(
start_argv(PROFILE, &size(), &host(), false, true).join(" "),
"colima start -p zakuro --runtime docker --vm-type vz --vz-rosetta \
--activate=false --ssh-config=false --mount /Users/jo/.zakuro:w \
-c 2 -m 2 -d 10"
);
assert_eq!(
start_argv(PROFILE, &size(), &host(), false, false).join(" "),
"colima start -p zakuro -c 2 -m 2"
);
assert!(start_argv(PROFILE, &size(), &host(), true, false)
.join(" ")
.ends_with("-d 10"));
}
#[test]
fn every_command_names_the_zakuro_profile() {
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Running", 4, 8, 10)));
d.on("ps -q", Ok(""));
d.with_config(GOOD_YAML);
let r = rt(&d);
r.ensure().unwrap();
let _ = r.start(&spec());
let _ = r.stop("w");
for c in d.calls() {
if c.contains("list --json") || c.starts_with("colima version") {
continue;
}
assert!(c.contains("-p zakuro"), "{c}");
assert!(!c.contains("-p default"), "{c}");
}
}
#[test]
fn the_default_profile_is_never_used() {
let d = Arc::new(Rec::default());
let r = ColimaRuntime::new(d.clone(), "default", Ok(size()), host());
assert!(r.ensure().unwrap_err().contains("never uses one the owner"));
assert!(!r.probe().available);
assert!(d.calls().iter().all(|c| !c.contains("start")));
}
#[test]
fn a_missing_profile_is_created_then_firewalled() {
let d = Arc::new(Rec::default());
rt(&d).ensure().unwrap();
let calls = d.calls();
assert_eq!(calls[0], "colima list --json");
assert!(calls[1].starts_with("colima start -p zakuro --runtime docker"));
assert!(calls[2].starts_with("colima ssh -p zakuro -- sudo sh -c set -e;"));
assert!(calls[2].contains("DOCKER-USER"), "{}", calls[2]);
assert_eq!(calls[3], "colima ssh -p zakuro -- docker version");
}
#[test]
fn a_matching_profile_is_adopted_untouched_and_a_changed_budget_resizes_when_idle() {
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Running", 2, 2, 10)));
d.with_config(GOOD_YAML);
rt(&d).ensure().unwrap();
assert!(!d
.calls()
.iter()
.any(|c| c.contains("colima start") || c.contains("colima stop")));
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Running", 4, 8, 10)));
d.on("ps -q", Ok(""));
d.with_config(GOOD_YAML);
rt(&d).ensure().unwrap();
let calls = d.calls();
let at = |p: &str| calls.iter().position(|c| c.starts_with(p)).unwrap();
assert!(at("colima stop -p zakuro") < at("colima start -p zakuro -c 2 -m 2"));
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Stopped", 1, 1, 5)));
d.with_config(GOOD_YAML);
rt(&d).ensure().unwrap();
assert!(d
.calls()
.contains(&"colima start -p zakuro -c 2 -m 2 -d 10".to_string()));
}
#[test]
fn a_busy_profile_is_not_resized() {
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Running", 4, 8, 10)));
d.on("ps -q", Ok("abc"));
d.with_config(GOOD_YAML);
let r = rt(&d);
r.ensure().unwrap();
assert!(!d.calls().iter().any(|c| c.contains("colima stop")));
assert!(r.resize_pending().unwrap());
}
#[test]
fn a_profile_with_the_home_mounted_is_refused() {
let writable_home = "mounts:\n - location: /Users/jo\n writable: true\n";
let defaults = "mounts: []\n";
for (yaml, why) in [(writable_home, "writable"), (defaults, "default mounts")] {
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Running", 2, 2, 10)));
d.with_config(yaml);
let e = rt(&d).ensure().unwrap_err();
assert!(e.contains("owner's home"), "{why}: {e}");
assert!(!rt(&d).probe().available);
assert!(!d.calls().iter().any(|c| c.contains("ssh")));
}
let d = Arc::new(Rec::default());
d.with_config(defaults);
assert!(rt(&d).ensure().is_err());
}
#[test]
fn colima_yaml_mounts_are_read() {
assert_eq!(
parse_mounts(GOOD_YAML),
Some(vec![("/Users/jo/.zakuro".to_string(), true)])
);
assert_eq!(parse_mounts("mounts: []\nx: 1\n"), None);
assert_eq!(parse_mounts("cpu: 2\n"), None);
let q = "mounts:\n - location: \"/a b\"\n writable: false\n - location: '/c'\n writable: true\nnext: 1\n - location: /no\n";
assert_eq!(
parse_mounts(q),
Some(vec![("/a b".to_string(), false), ("/c".to_string(), true)])
);
}
#[test]
fn a_gpu_is_refused_and_workloads_run_through_the_profiles_docker() {
let d = Arc::new(Rec::default());
let mut sp = spec();
sp.limits = Limits::new(0.5, 1.0, Gpus::Count(1));
assert!(rt(&d)
.start(&sp)
.unwrap_err()
.contains("no GPU passthrough"));
assert!(d.calls().is_empty());
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Running", 2, 2, 10)));
d.on("docker run", Ok("cid"));
d.with_config(GOOD_YAML);
assert_eq!(rt(&d).start(&spec()).unwrap(), "cid");
let run = d
.calls()
.into_iter()
.find(|c| c.contains("docker run"))
.unwrap();
assert!(
run.starts_with("colima ssh -p zakuro -- docker run --rm -d --name zc-share-w0"),
"{run}"
);
assert!(run.contains("--cpus 0.5 --memory 1024m"), "{run}");
assert!(run.contains("-v /Users/jo/.zakuro/work:/work"), "{run}");
let mut sp = spec();
sp.mounts = vec![("/Users/jo".into(), "/h".into())];
assert!(rt(&Arc::new(Rec::default()))
.start(&sp)
.unwrap_err()
.contains("outside the zakuro work directory"));
}
#[test]
fn limits_stop_health_and_allocations() {
let d = Arc::new(Rec::default());
d.on("exec zc-share-w0 sh -c", Ok("50000 100000\n1073741824\n0"));
let l = rt(&d).limits("zc-share-w0").unwrap();
assert_eq!((l.cpu_millis, l.memory_bytes), (500, 1073741824));
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Stopped", 2, 2, 10)));
rt(&d).stop("w").unwrap();
assert!(rt(&d).allocations().unwrap().is_empty());
assert!(!d.calls().iter().any(|c| c.contains("ssh")));
let d = Arc::new(Rec::default());
d.on("list --json", Ok(&list_line("Running", 2, 2, 10)));
d.on(
"rm -f",
Err("Error response from daemon: No such container: w"),
);
rt(&d).stop("w").unwrap();
d.on("docker ps --filter", Ok("w|500m,1073741824"));
assert_eq!(rt(&d).allocations().unwrap().len(), 1);
let d = Arc::new(Rec::default());
d.on("inspect -f", Ok("true|2026-01-01T00:00:00Z|0"));
assert!(rt(&d).health("w").is_ok());
}
#[test]
fn verify_image_checks_the_exact_digest() {
let d = Arc::new(Rec::default());
d.on("image inspect", Ok(r#"sha256:aaa|["img@sha256:bbb"]"#));
let r = rt(&d);
assert!(r.verify_image("img", Some("img@sha256:bbb")).is_ok());
assert!(r
.verify_image("img", Some("sha256:ccc"))
.unwrap_err()
.contains("does not match"));
}
#[test]
fn the_probe_says_why() {
let d = Arc::new(Rec::default());
d.on("version", Err("colima is not installed (No such file)"));
let p = rt(&d).probe();
assert!(
!p.available && p.detail.contains("brew install colima"),
"{}",
p.detail
);
let d = Arc::new(Rec::default());
d.on("version", Ok("colima version 0.5.0\ngit commit: x"));
assert!(rt(&d).probe().detail.contains("too old"));
let mut h = host();
h.macos = false;
let r = ColimaRuntime::new(Arc::new(Rec::default()), PROFILE, Ok(size()), h);
assert_eq!(r.probe().detail, "macOS only");
let d = Arc::new(Rec::default());
d.on("version", Ok("colima version 0.10.3\ngit commit: 00f6"));
let p = rt(&d).probe();
assert!(
p.available && p.detail.contains("not created yet"),
"{}",
p.detail
);
d.on("list --json", Ok(&list_line("Running", 2, 2, 10)));
d.with_config(GOOD_YAML);
assert!(rt(&d)
.probe()
.detail
.contains("running (2 cpu, 2.0 GiB memory)"));
}
struct Cleanup(String);
impl Drop for Cleanup {
fn drop(&mut self) {
let bin = resolve_binary(
"colima",
"ZAKURO_COLIMA",
&|k| std::env::var(k).ok(),
&|p| p.is_file(),
);
let _ = std::process::Command::new(bin)
.args(["delete", "-f", "-p", &self.0])
.output();
eprintln!("[real-colima] deleted profile {}", self.0);
}
}
#[test]
#[ignore]
fn real_colima_profile_runs_a_limited_container_and_blocks_the_host() {
if std::env::var("ZAKURO_TEST_REAL_COLIMA").as_deref() != Ok("1") {
return;
}
let name = format!("zctest-{}", std::process::id());
assert!(name != "zakuro" && name != "default");
let cli: Arc<dyn ColimaCli> = Arc::new(ColimaShell::new());
eprintln!(
"[real-colima] existing profiles (untouched): {:?}",
cli.run(&s(&["colima", "list"]))
);
let work = std::fs::canonicalize(std::env::temp_dir())
.unwrap()
.join(format!("{name}-work"));
std::fs::create_dir_all(work.join("w")).unwrap();
let _cleanup = Cleanup(name.clone());
let mut h = Host::detect();
h.work_dir = Some(work.clone());
let size = SandboxSize {
limits: Limits::new(2.0, 2.0, Gpus::None),
disk_bytes: 10 * 1024 * MIB,
};
let r = ColimaRuntime::new(cli.clone(), &name, Ok(size), h);
eprintln!("[real-colima] probe before: {:?}", r.probe());
assert!(r.probe().available);
let spec = StartSpec {
name: "zctest-w0".into(),
image: "alpine:3".into(),
network: None,
create_network: false,
labels: vec![],
mounts: vec![(work.join("w").display().to_string(), "/work".into())],
publish: vec![],
env: vec![],
cmd: s(&["sleep", "600"]),
limits: Limits::new(0.5, 0.25, Gpus::None),
remove_on_exit: false,
hardened: true,
};
let id = r.start(&spec).expect("start");
eprintln!("[real-colima] started container {id}");
eprintln!("[real-colima] probe after: {:?}", r.probe());
let l = r.limits("zctest-w0").expect("limits");
eprintln!("[real-colima] limits read back from inside: {l}");
assert_eq!(l.cpu_millis, 500);
assert_eq!(l.memory_bytes, 256 * MIB);
assert!(r.health("zctest-w0").unwrap().running);
assert!(r.verify_image("alpine:3", None).is_ok());
assert_eq!(r.allocations().unwrap().len(), 1);
let out = r
.exec(
"zctest-w0",
&s(&["sh", "-c", "echo 'a b'; echo $((1+2)); echo hi > /work/f"]),
false,
)
.unwrap();
eprintln!("[real-colima] exec output: {out:?}");
assert_eq!(out, "a b\n3");
assert_eq!(
std::fs::read_to_string(work.join("w/f")).unwrap().trim(),
"hi"
);
let l = std::net::TcpListener::bind("0.0.0.0:0").unwrap();
let port = l.local_addr().unwrap().port().to_string();
let guest = |cmd: &str| cli.run(&s(&["colima", "ssh", "-p", &name, "--", "sh", "-c", cmd]));
let gw = guest("getent hosts host.lima.internal | cut -d' ' -f1").unwrap();
eprintln!("[real-colima] host gateway in the guest: {gw}");
let base = guest(&format!(
"timeout 3 bash -c 'echo > /dev/tcp/{gw}/{port}' && echo reachable"
));
eprintln!("[real-colima] guest -> mac listener (baseline): {base:?}");
let probe = |cmd: &str| r.exec("zctest-w0", &s(&["sh", "-c", cmd]), false);
let ctr = probe(&format!(
"nc -z -w 3 {gw} {port} && echo reachable || echo blocked"
));
eprintln!("[real-colima] container -> mac listener: {ctr:?}");
let net = probe("nc -z -w 5 1.1.1.1 443 && echo internet-ok || echo internet-blocked");
eprintln!("[real-colima] container -> 1.1.1.1:443: {net:?}");
let dns = probe("nslookup example.com >/dev/null 2>&1 && echo dns-ok || echo dns-failed");
eprintln!("[real-colima] container dns: {dns:?}");
drop(l);
assert_eq!(
base.as_deref(),
Ok("reachable"),
"baseline: guest must reach the Mac"
);
assert_eq!(ctr.as_deref(), Ok("blocked"));
assert_eq!(net.as_deref(), Ok("internet-ok"));
assert_eq!(dns.as_deref(), Ok("dns-ok"));
r.stop("zctest-w0").unwrap();
assert!(r.health("zctest-w0").is_err());
eprintln!(
"[real-colima] stopped; allocations now {:?}",
r.allocations().unwrap()
);
}
}